Skip to content

Commit ec7a9cf

Browse files
loganjLarry
andcommitted
fix(desktop): order unnamed roster members by full canonical npub
The roster ordered members by the compact `npub1abcd…wxyz` display label — a recognition aid that hides almost the entire key — so two distinct identities sharing an npub head and checksum tail collapsed into one roster position. Sort unnamed members by their full canonical npub instead, and break every collation-equal name surface — duplicate authored names, matching labels, invalid keys — by the full identity key, so incoming membership-event order is never the tie policy. The compact label stays display-only and unchanged. - memberUtils: new shared `compareMemberNames` owns the name stage — surface (authored name, else full canonical npub), then full identity key for ties. `compareMembersByRole` delegates to it with its current-user and role precedence unchanged. - MembersSidebar: the add-member modal comparator keeps its intentionally coarser owner/admin rank and current-user-first priority and delegates the same name stage. - e2e: the virtualization spec's ordering comment follows the new rule (comment-only; the spec already resolves members from the rendered window). - unit tests: five cases bind the production comparator — full-npub vs compact-label disagreement, duplicate-name identity-key tie-break, role precedence, current-user precedence, invalid-key determinism. Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz> Signed-off-by: Logan Johnson <[email protected]>
1 parent a1ffa77 commit ec7a9cf

4 files changed

Lines changed: 189 additions & 6 deletions

File tree

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
import { strict as assert } from "node:assert";
2+
import test from "node:test";
3+
4+
import { canonicalNpub, truncateNpub } from "@/shared/lib/pubkey";
5+
import { compareMembersByRole, formatMemberName } from "./memberUtils.ts";
6+
7+
// Sequential-value pubkeys, the same shape as the members-sidebar e2e
8+
// roster fixture: every full npub shares the `npub1qqq…` head, so the
9+
// compact label is decided by the checksum tail while the full npub
10+
// diverges mid-key. These two keys disagree between the two orders.
11+
const V5_HEX =
12+
"0000000000000000000000000000000000000000000000000000000000000005";
13+
const V5_NPUB =
14+
"npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzsfj2hcx";
15+
const V24_HEX =
16+
"0000000000000000000000000000000000000000000000000000000000000018";
17+
const V24_NPUB =
18+
"npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvq532w5c";
19+
20+
function member(pubkey, overrides = {}) {
21+
return {
22+
pubkey,
23+
role: "member",
24+
isAgent: false,
25+
joinedAt: "2026-09-08T00:00:00Z",
26+
displayName: null,
27+
...overrides,
28+
};
29+
}
30+
31+
function rosterOrder(members, currentPubkey) {
32+
return [...members]
33+
.sort((left, right) => compareMembersByRole(left, right, currentPubkey))
34+
.map((item) => item.pubkey);
35+
}
36+
37+
test("unnamed members order by full canonical npub, not the compact label", () => {
38+
assert.equal(canonicalNpub(V5_HEX), V5_NPUB);
39+
assert.equal(canonicalNpub(V24_HEX), V24_NPUB);
40+
// Compact labels order V5 first (`…2hcx` < `…2w5c`); the full npubs
41+
// disagree (`…vq53…` < `…zsfj…`). Ordering follows the full key.
42+
assert.ok(truncateNpub(V5_HEX).localeCompare(truncateNpub(V24_HEX)) < 0);
43+
assert.ok(V24_NPUB.localeCompare(V5_NPUB) < 0);
44+
45+
const v5 = member(V5_HEX);
46+
const v24 = member(V24_HEX);
47+
48+
assert.deepEqual(rosterOrder([v5, v24]), [V24_HEX, V5_HEX]);
49+
assert.deepEqual(rosterOrder([v24, v5]), [V24_HEX, V5_HEX]);
50+
51+
// The compact 8+4 label stays the display form.
52+
assert.equal(formatMemberName(v5), "npub1qqq…2hcx");
53+
assert.equal(formatMemberName(v24), "npub1qqq…2w5c");
54+
55+
// Authored names still order against npub surfaces as before.
56+
const bob = member("0".repeat(64), { displayName: "Bob" });
57+
assert.deepEqual(rosterOrder([v5, bob, v24]), [
58+
"0".repeat(64),
59+
V24_HEX,
60+
V5_HEX,
61+
]);
62+
});
63+
64+
test("duplicate authored names tie-break by the full identity key", () => {
65+
const lowHexName = member(V5_HEX, { displayName: "Ada" });
66+
const highHexName = member(V24_HEX, { displayName: "Ada" });
67+
68+
// Same name, distinct keys: the tie breaks by canonical npub (which
69+
// reverses the raw hex order of these two keys), in both input orders.
70+
assert.deepEqual(rosterOrder([lowHexName, highHexName]), [V24_HEX, V5_HEX]);
71+
assert.deepEqual(rosterOrder([highHexName, lowHexName]), [V24_HEX, V5_HEX]);
72+
});
73+
74+
test("role precedence still outranks the name stage", () => {
75+
const owner = member("1".repeat(64), { role: "owner", displayName: "Zed" });
76+
const admin = member("2".repeat(64), { role: "admin", displayName: "Yan" });
77+
const plain = member("3".repeat(64), { role: "member", displayName: "Xan" });
78+
const guest = member("4".repeat(64), { role: "guest", displayName: "Wes" });
79+
const bot = member("5".repeat(64), { role: "bot", displayName: "Ann" });
80+
81+
assert.deepEqual(rosterOrder([bot, guest, plain, admin, owner]), [
82+
"1".repeat(64),
83+
"2".repeat(64),
84+
"3".repeat(64),
85+
"4".repeat(64),
86+
"5".repeat(64),
87+
]);
88+
});
89+
90+
test("the current member still sorts first in compareMembersByRole", () => {
91+
const current = member(V24_HEX);
92+
const owner = member("1".repeat(64), { role: "owner", displayName: "Ada" });
93+
94+
assert.deepEqual(rosterOrder([owner, current], V24_HEX), [
95+
V24_HEX,
96+
"1".repeat(64),
97+
]);
98+
assert.ok(compareMembersByRole(current, owner, V24_HEX) < 0);
99+
assert.ok(compareMembersByRole(owner, current, V24_HEX) > 0);
100+
101+
// Without a current pubkey, roles lead again.
102+
assert.ok(compareMembersByRole(current, owner) > 0);
103+
});
104+
105+
test("invalid keys keep the neutral surface and break ties deterministically", () => {
106+
const first = member("not-a-key");
107+
const second = member("zzz-definitely-not-a-key");
108+
109+
// Both render the neutral label — never raw input — and the label
110+
// collision breaks by the normalized key, not incoming order.
111+
assert.equal(formatMemberName(first), "Unavailable");
112+
assert.equal(formatMemberName(second), "Unavailable");
113+
assert.deepEqual(rosterOrder([second, first]), [
114+
"not-a-key",
115+
"zzz-definitely-not-a-key",
116+
]);
117+
assert.deepEqual(rosterOrder([first, second]), [
118+
"not-a-key",
119+
"zzz-definitely-not-a-key",
120+
]);
121+
});

‎desktop/src/features/channels/lib/memberUtils.ts‎

Lines changed: 60 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,10 @@
11
import type { ChannelMember } from "@/shared/api/types";
2-
import { truncateNpub } from "@/shared/lib/pubkey";
2+
import {
3+
canonicalNpub,
4+
normalizePubkey,
5+
truncateNpub,
6+
UNAVAILABLE_KEY_LABEL,
7+
} from "@/shared/lib/pubkey";
38

49
export const roleOrder: Record<ChannelMember["role"], number> = {
510
owner: 0,
@@ -20,6 +25,59 @@ export function formatMemberName(
2025
return member.displayName ?? truncateNpub(member.pubkey);
2126
}
2227

28+
/**
29+
* Ordering surface for a member's name: the authored name when present,
30+
* else the FULL canonical npub. Separate from `formatMemberName` — the
31+
* compact `npub1abcd…wxyz` label is display-only, and ordering on it would
32+
* collapse two distinct identities that merely share a prefix and tail.
33+
* Undisplayable keys keep the neutral label as their surface, exactly as
34+
* they render.
35+
*/
36+
function memberNameSurface(member: ChannelMember): string {
37+
return (
38+
member.displayName ?? canonicalNpub(member.pubkey) ?? UNAVAILABLE_KEY_LABEL
39+
);
40+
}
41+
42+
/**
43+
* Full identity key used to break name-surface ties: the canonical npub of
44+
* a valid identity, else the normalized raw key so every tie is decided.
45+
* An ordering key only — never rendered or copied.
46+
*/
47+
function memberIdentityKey(member: ChannelMember): string {
48+
return canonicalNpub(member.pubkey) ?? normalizePubkey(member.pubkey);
49+
}
50+
51+
/**
52+
* Shared name/key ordering authority for the roster comparators.
53+
*
54+
* Authored names keep the existing `localeCompare` semantics; unnamed
55+
* members order by their full canonical npub (the compact label stays
56+
* display-only); collation-equal surfaces — duplicate authored names,
57+
* matching labels, invalid keys — break by full identity key, so the
58+
* incoming membership-event order is never the tie policy. Comparators
59+
* layer their own role/current-user precedence around this stage; this
60+
* helper owns only the name ordering.
61+
*/
62+
export function compareMemberNames(
63+
left: ChannelMember,
64+
right: ChannelMember,
65+
): number {
66+
const surfaceDelta = memberNameSurface(left).localeCompare(
67+
memberNameSurface(right),
68+
);
69+
if (surfaceDelta !== 0) {
70+
return surfaceDelta;
71+
}
72+
73+
const leftKey = memberIdentityKey(left);
74+
const rightKey = memberIdentityKey(right);
75+
if (leftKey === rightKey) {
76+
return 0;
77+
}
78+
return leftKey < rightKey ? -1 : 1;
79+
}
80+
2381
export function compareMembersByRole(
2482
left: ChannelMember,
2583
right: ChannelMember,
@@ -35,5 +93,5 @@ export function compareMembersByRole(
3593
if (roleDelta !== 0) {
3694
return roleDelta;
3795
}
38-
return formatMemberName(left).localeCompare(formatMemberName(right));
96+
return compareMemberNames(left, right);
3997
}

‎desktop/src/features/channels/ui/MembersSidebar.tsx‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,10 @@ import {
1616
} from "@/features/agents/lib/agentAutocompleteEligibility";
1717
import { useIsArchivedPredicate } from "@/features/identity-archive/hooks";
1818
import { useClassifiedMembers } from "@/features/channels/lib/useClassifiedMembers";
19-
import { formatMemberName } from "@/features/channels/lib/memberUtils";
19+
import {
20+
compareMemberNames,
21+
formatMemberName,
22+
} from "@/features/channels/lib/memberUtils";
2023
import {
2124
canAddChannelMembers,
2225
PRIVATE_CHANNEL_ADD_DENIED_MESSAGE,
@@ -120,7 +123,7 @@ function compareMembersForModal(
120123
if (currentPubkey && left.pubkey === currentPubkey) return -1;
121124
if (currentPubkey && right.pubkey === currentPubkey) return 1;
122125

123-
return formatMemberName(left).localeCompare(formatMemberName(right));
126+
return compareMemberNames(left, right);
124127
}
125128

126129
type MembersSidebarProps = {

‎desktop/tests/e2e/channels.spec.ts‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4177,8 +4177,9 @@ test("members sidebar virtualizes large channel rosters", async ({ page }) => {
41774177
expect(await memberRows.count()).toBeLessThan(50);
41784178

41794179
// Generated members have no display name, so the roster sorts them by
4180-
// their npub fallback label: these sequential pubkeys share a `npub1qqq…`
4181-
// prefix and order by the checksum tail, not their numeric value. Resolve
4180+
// their full canonical npub: these sequential pubkeys share an
4181+
// `npub1qqq…` head and diverge mid-key, while the compact label's
4182+
// checksum tail is display-only and decides nothing. Resolve
41824183
// a generated member from the rows the initial window actually rendered
41834184
// instead of assuming `pubkeys[0]` sorts into that window.
41844185
const generatedPubkeySet = new Set(pubkeys);

0 commit comments

Comments
 (0)