Compare commits
6 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
8c456ec522 | ||
|
|
e734f33542 | ||
|
|
6ad2d37a23 | ||
|
|
28ce7bce1b | ||
|
|
894a163111 | ||
|
|
efe9d977cd |
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"VERSION": "v0.7.48",
|
||||
"VERSION_NUMBER": "0.7.48",
|
||||
"BUILD_DATE": "2026-06-26T14:17:56.525Z"
|
||||
"VERSION": "v0.7.54",
|
||||
"VERSION_NUMBER": "0.7.54",
|
||||
"BUILD_DATE": "2026-06-27T01:33:34.109Z"
|
||||
}
|
||||
|
||||
@@ -6443,128 +6443,162 @@ async function handleSetRelayEventLogging(requestId, enabled, port) {
|
||||
// from followed authors who write to relays the user does not subscribe to.
|
||||
// For each discovered relay we also report which followed pubkeys it serves,
|
||||
// by inverting ndk.outboxTracker.data (pubkey -> OutboxItem{writeRelays}).
|
||||
function shortHexPubkey(hex) {
|
||||
if (!hex || hex.length < 16) return hex || '-';
|
||||
return `${hex.slice(0, 8)}…${hex.slice(-4)}`;
|
||||
}
|
||||
|
||||
// Cache for discovered relays — rebuilt only when the contact list changes.
|
||||
// The version suffix forces a rebuild when the handler code changes (e.g.
|
||||
// adding servingNames).
|
||||
let discoveredRelaysCache = null;
|
||||
let discoveredRelaysCacheKey = '';
|
||||
const DISCOVERED_RELAYS_CACHE_VERSION = 'v2-names';
|
||||
|
||||
async function handleGetDiscoveredRelays(requestId, port) {
|
||||
try {
|
||||
if (!ndk?.pool?.relays) {
|
||||
port.postMessage({
|
||||
type: 'getDiscoveredRelaysResult',
|
||||
requestId,
|
||||
relays: []
|
||||
});
|
||||
if (!ndk) {
|
||||
port.postMessage({ type: 'getDiscoveredRelaysResult', requestId, relays: [] });
|
||||
return;
|
||||
}
|
||||
|
||||
// Build the set of the user's own relay URLs (normalized) from
|
||||
// relayTypes (kind 10002). These are the "configured" relays; anything
|
||||
// else in the pool is a discovered/temporary outbox relay.
|
||||
// relayTypes (kind 10002). These are the "configured" relays.
|
||||
const ownRelays = new Set();
|
||||
for (const url of relayTypes.keys()) {
|
||||
const normalized = normalizeRelayUrl(url);
|
||||
if (normalized) ownRelays.add(normalized);
|
||||
}
|
||||
|
||||
// Build relayUrl -> [pubkeys] map by inverting the outbox tracker.
|
||||
// ndk.outboxTracker.data is an LRUCache (typescript-lru-cache).
|
||||
// We try a few iteration strategies to be resilient to API differences.
|
||||
const relayServesPubkeys = new Map(); // normalizedUrl -> Set<pubkey>
|
||||
try {
|
||||
const trackerData = ndk?.outboxTracker?.data;
|
||||
if (trackerData) {
|
||||
// Debug: log what the LRU cache looks like
|
||||
const trackerKeys = typeof trackerData.keys === 'function' ? Array.from(trackerData.keys()) :
|
||||
(trackerData instanceof Map ? Array.from(trackerData.keys()) : []);
|
||||
console.log('[Worker] getDiscoveredRelays: tracker has', trackerKeys.length, 'entries');
|
||||
// Get the user's kind 3 contact list from the Dexie cache to
|
||||
// determine the followed pubkeys. Use the contact list's created_at
|
||||
// as a cache key so we only rebuild when it changes.
|
||||
const kind3Events = await ndk.fetchEvents(
|
||||
{ kinds: [3], authors: [currentPubkey], limit: 1 },
|
||||
{ cacheUsage: 'ONLY_CACHE' }
|
||||
);
|
||||
const latestKind3 = kind3Events && kind3Events.size > 0
|
||||
? Array.from(kind3Events).sort((a, b) => (b.created_at || 0) - (a.created_at || 0))[0]
|
||||
: null;
|
||||
const followedPubkeys = latestKind3 ? extractFollowedPubkeysFromKind3(latestKind3) : [];
|
||||
const cacheKey = `${DISCOVERED_RELAYS_CACHE_VERSION}_${latestKind3?.id || 'none'}_${latestKind3?.created_at || 0}`;
|
||||
|
||||
let pubkeysProcessed = 0;
|
||||
let pubkeysWithWriteRelays = 0;
|
||||
// Rebuild the relay→[pubkeys] mapping from follows' kind 10002 events
|
||||
// in the Dexie cache if the contact list has changed.
|
||||
if (discoveredRelaysCacheKey !== cacheKey) {
|
||||
discoveredRelaysCacheKey = cacheKey;
|
||||
discoveredRelaysCache = null; // invalidate
|
||||
|
||||
const collectForPubkey = (pubkey) => {
|
||||
pubkeysProcessed++;
|
||||
if (followedPubkeys.length > 0) {
|
||||
// Query all follows' kind 10002 events from the Dexie cache.
|
||||
// This is the persistent data source — no 2-minute TTL like
|
||||
// the outbox tracker.
|
||||
const relayServesPubkeys = new Map(); // normalizedUrl -> Set<pubkey>
|
||||
|
||||
// Process in batches of 400 to avoid filter size limits.
|
||||
for (let i = 0; i < followedPubkeys.length; i += 400) {
|
||||
const batch = followedPubkeys.slice(i, i + 400);
|
||||
try {
|
||||
const outboxItem = trackerData.get(pubkey);
|
||||
if (!outboxItem) return;
|
||||
const writeRelays = outboxItem.writeRelays;
|
||||
if (!writeRelays || writeRelays.size === 0) return;
|
||||
pubkeysWithWriteRelays++;
|
||||
for (const r of writeRelays) {
|
||||
const rUrl = r?.url ? normalizeRelayUrl(r.url) : (typeof r === 'string' ? normalizeRelayUrl(r) : null);
|
||||
if (!rUrl) continue;
|
||||
if (!relayServesPubkeys.has(rUrl)) {
|
||||
relayServesPubkeys.set(rUrl, new Set());
|
||||
const k10002Events = await ndk.fetchEvents(
|
||||
{ kinds: [10002], authors: batch },
|
||||
{ cacheUsage: 'ONLY_CACHE' }
|
||||
);
|
||||
if (k10002Events && k10002Events.size > 0) {
|
||||
// For each author, keep only the latest kind 10002.
|
||||
const latestByAuthor = new Map();
|
||||
for (const evt of k10002Events) {
|
||||
const existing = latestByAuthor.get(evt.pubkey);
|
||||
if (!existing || (evt.created_at || 0) > (existing.created_at || 0)) {
|
||||
latestByAuthor.set(evt.pubkey, evt);
|
||||
}
|
||||
}
|
||||
// Parse 'r' tags from each author's latest kind 10002.
|
||||
for (const [pubkey, evt] of latestByAuthor) {
|
||||
if (!Array.isArray(evt.tags)) continue;
|
||||
for (const tag of evt.tags) {
|
||||
if (tag[0] === 'r' && tag[1]) {
|
||||
const relayType = tag[2] || 'both';
|
||||
// Include 'write' and 'both' relays — these are
|
||||
// where the follow posts content.
|
||||
if (relayType === 'write' || relayType === 'both') {
|
||||
const normalized = normalizeRelayUrl(tag[1]);
|
||||
if (!normalized) continue;
|
||||
if (!relayServesPubkeys.has(normalized)) {
|
||||
relayServesPubkeys.set(normalized, new Set());
|
||||
}
|
||||
relayServesPubkeys.get(normalized).add(pubkey);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
relayServesPubkeys.get(rUrl).add(pubkey);
|
||||
}
|
||||
} catch (_) {
|
||||
// ignore per-pubkey errors
|
||||
}
|
||||
};
|
||||
} catch (_) {}
|
||||
}
|
||||
|
||||
// Strategy 1: standard Map-like entries()
|
||||
let iterated = false;
|
||||
// Look up profile names for all serving pubkeys from the Dexie
|
||||
// profiles table so we can display usernames instead of pubkeys.
|
||||
const pubkeyToName = new Map();
|
||||
try {
|
||||
if (typeof trackerData.entries === 'function') {
|
||||
for (const [pubkey] of trackerData.entries()) {
|
||||
collectForPubkey(pubkey);
|
||||
const adapter = ndk?.cacheAdapter?.adapter;
|
||||
if (adapter?.db?.profiles) {
|
||||
const allServingPubkeys = new Set();
|
||||
for (const servingSet of relayServesPubkeys.values()) {
|
||||
for (const pk of servingSet) allServingPubkeys.add(pk);
|
||||
}
|
||||
// Query profiles table for all serving pubkeys.
|
||||
for (const pk of allServingPubkeys) {
|
||||
try {
|
||||
const row = await adapter.db.profiles.get(pk);
|
||||
if (row) {
|
||||
const name = row.displayName || row.name || '';
|
||||
if (name) pubkeyToName.set(pk, name);
|
||||
}
|
||||
} catch (_) {}
|
||||
}
|
||||
iterated = true;
|
||||
}
|
||||
} catch (_) {}
|
||||
|
||||
// Strategy 2: keys() + get()
|
||||
if (!iterated) {
|
||||
try {
|
||||
if (typeof trackerData.keys === 'function') {
|
||||
for (const pubkey of trackerData.keys()) {
|
||||
collectForPubkey(pubkey);
|
||||
}
|
||||
iterated = true;
|
||||
}
|
||||
} catch (_) {}
|
||||
// Build the discovered relays list: relays that are NOT in the
|
||||
// user's own kind 10002 but ARE in follows' kind 10002.
|
||||
const relays = [];
|
||||
for (const [relayUrl, servingSet] of relayServesPubkeys) {
|
||||
if (ownRelays.has(relayUrl)) continue; // skip user's own relays
|
||||
// Check live connection status from the pool.
|
||||
const poolRelay = ndk.pool?.relays?.get(relayUrl);
|
||||
const pubkeys = Array.from(servingSet);
|
||||
// Map pubkeys to names, falling back to truncated pubkey.
|
||||
const names = pubkeys.map(pk =>
|
||||
pubkeyToName.get(pk) || shortHexPubkey(pk)
|
||||
);
|
||||
relays.push({
|
||||
url: relayUrl,
|
||||
status: poolRelay?.status || 0,
|
||||
connected: poolRelay ? poolRelay.status >= 5 : false,
|
||||
servingPubkeys: pubkeys,
|
||||
servingNames: names
|
||||
});
|
||||
}
|
||||
|
||||
// Strategy 3: iterate as Map directly
|
||||
if (!iterated && trackerData instanceof Map) {
|
||||
for (const pubkey of trackerData.keys()) {
|
||||
collectForPubkey(pubkey);
|
||||
}
|
||||
iterated = true;
|
||||
}
|
||||
|
||||
// Strategy 4: try internal storage if LRU cache has it
|
||||
if (!iterated) {
|
||||
try {
|
||||
// Some LRU caches store entries in an internal Map or object
|
||||
const internal = trackerData._map || trackerData.cache || trackerData._cache;
|
||||
if (internal instanceof Map) {
|
||||
for (const [pubkey] of internal) {
|
||||
collectForPubkey(pubkey);
|
||||
}
|
||||
iterated = true;
|
||||
}
|
||||
} catch (_) {}
|
||||
}
|
||||
|
||||
console.log('[Worker] getDiscoveredRelays: processed', pubkeysProcessed, 'pubkeys,', pubkeysWithWriteRelays, 'with write relays, iterated:', iterated, ', relayServesPubkeys size:', relayServesPubkeys.size);
|
||||
} else {
|
||||
console.log('[Worker] getDiscoveredRelays: no outbox tracker data available');
|
||||
// Sort by serving count (most follows first), then by URL.
|
||||
relays.sort((a, b) => {
|
||||
const countDiff = b.servingPubkeys.length - a.servingPubkeys.length;
|
||||
if (countDiff !== 0) return countDiff;
|
||||
return a.url.localeCompare(b.url);
|
||||
});
|
||||
discoveredRelaysCache = relays;
|
||||
}
|
||||
} catch (err) {
|
||||
console.warn('[Worker] getDiscoveredRelays: outbox tracker inversion failed:', err?.message || err);
|
||||
}
|
||||
|
||||
const relays = [];
|
||||
for (const relay of ndk.pool.relays.values()) {
|
||||
const normalized = normalizeRelayUrl(relay?.url);
|
||||
if (!normalized) continue;
|
||||
// Skip relays that are part of the user's own kind 10002 list.
|
||||
if (ownRelays.has(normalized)) continue;
|
||||
|
||||
const servingSet = relayServesPubkeys.get(normalized);
|
||||
relays.push({
|
||||
url: relay.url,
|
||||
status: relay.status,
|
||||
connected: relay.status >= 5,
|
||||
servingPubkeys: servingSet ? Array.from(servingSet) : []
|
||||
// If we have cached data, update the live connection status from the
|
||||
// pool without rebuilding the entire mapping.
|
||||
let relays = discoveredRelaysCache || [];
|
||||
if (relays.length > 0 && ndk.pool?.relays) {
|
||||
relays = relays.map(r => {
|
||||
const poolRelay = ndk.pool.relays.get(r.url);
|
||||
return {
|
||||
...r,
|
||||
status: poolRelay?.status || r.status || 0,
|
||||
connected: poolRelay ? poolRelay.status >= 5 : r.connected
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
@@ -6852,7 +6886,7 @@ self.onconnect = (event) => {
|
||||
|
||||
connectedPorts.push(port);
|
||||
|
||||
port.onmessage = async (e) => {
|
||||
port.onmessage = (e) => {
|
||||
const {
|
||||
type,
|
||||
pubkey,
|
||||
@@ -6894,11 +6928,11 @@ self.onconnect = (event) => {
|
||||
|
||||
switch(type) {
|
||||
case 'init':
|
||||
await handleInit(pubkey, port);
|
||||
void handleInit(pubkey, port);
|
||||
break;
|
||||
|
||||
case 'subscribe':
|
||||
await handleSubscribe(subId, filters, opts, port);
|
||||
void handleSubscribe(subId, filters, opts, port);
|
||||
break;
|
||||
|
||||
case 'unsubscribe':
|
||||
@@ -6906,35 +6940,38 @@ self.onconnect = (event) => {
|
||||
break;
|
||||
|
||||
case 'publish':
|
||||
await handlePublish(requestId, event, port);
|
||||
void handlePublish(requestId, event, port);
|
||||
break;
|
||||
|
||||
case 'publishRaw':
|
||||
await handlePublishRaw(requestId, event, port);
|
||||
void handlePublishRaw(requestId, event, port);
|
||||
break;
|
||||
|
||||
case 'publishRawToRelay':
|
||||
await handlePublishRawToRelay(requestId, event, relayUrl, port);
|
||||
void handlePublishRawToRelay(requestId, event, relayUrl, port);
|
||||
break;
|
||||
|
||||
case 'sendNip17Message':
|
||||
await handleSendNip17Message(requestId, recipientPubkey, content, port);
|
||||
void handleSendNip17Message(requestId, recipientPubkey, content, port);
|
||||
break;
|
||||
|
||||
case 'fetchEvents':
|
||||
await handleFetchEvents(requestId, filters, relayUrl, port);
|
||||
void handleFetchEvents(requestId, filters, relayUrl, port);
|
||||
break;
|
||||
|
||||
case 'ndkFetchEvents':
|
||||
await handleNdkFetchEvents(requestId, filters, port);
|
||||
void handleNdkFetchEvents(requestId, filters, port);
|
||||
break;
|
||||
|
||||
case 'warmOutbox':
|
||||
await handleWarmOutbox(requestId, pubkeys, port);
|
||||
// Don't await — trackUsers involves network I/O to outbox pool
|
||||
// relays and would block the entire message dispatch loop,
|
||||
// starving getRelayData/getRelayStats messages.
|
||||
void handleWarmOutbox(requestId, pubkeys, port);
|
||||
break;
|
||||
|
||||
case 'setRelayEventLogging':
|
||||
await handleSetRelayEventLogging(requestId, enabled, port);
|
||||
void handleSetRelayEventLogging(requestId, enabled, port);
|
||||
break;
|
||||
|
||||
case 'getDiscoveredRelays':
|
||||
@@ -6970,109 +7007,101 @@ self.onconnect = (event) => {
|
||||
break;
|
||||
|
||||
case 'queryCache':
|
||||
await handleQueryCache(requestId, filters, port);
|
||||
void handleQueryCache(requestId, filters, port);
|
||||
break;
|
||||
|
||||
case 'purgePlaylistCache':
|
||||
await handlePurgePlaylistCache(requestId, playlistIdentifier, ownerPubkey, playlistKind, eventIds, port);
|
||||
void handlePurgePlaylistCache(requestId, playlistIdentifier, ownerPubkey, playlistKind, eventIds, port);
|
||||
break;
|
||||
|
||||
case 'syncMuteList': {
|
||||
try {
|
||||
const result = await loadWorkerMuteList(currentPubkey, { reason: 'sync-request' });
|
||||
port.postMessage({
|
||||
type: 'response',
|
||||
requestId,
|
||||
data: { success: true, result }
|
||||
case 'syncMuteList':
|
||||
void loadWorkerMuteList(currentPubkey, { reason: 'sync-request' })
|
||||
.then((result) => {
|
||||
port.postMessage({ type: 'response', requestId, data: { success: true, result } });
|
||||
})
|
||||
.catch((error) => {
|
||||
port.postMessage({ type: 'response', requestId, error: error?.message || String(error) });
|
||||
});
|
||||
} catch (error) {
|
||||
port.postMessage({
|
||||
type: 'response',
|
||||
requestId,
|
||||
error: error?.message || String(error)
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 'fetchCachedProfile':
|
||||
await handleFetchCachedProfile(requestId, e.data.pubkey, port);
|
||||
void handleFetchCachedProfile(requestId, e.data.pubkey, port);
|
||||
break;
|
||||
|
||||
case 'storeProfile':
|
||||
await handleStoreProfile(e.data.pubkey, e.data.profile);
|
||||
void handleStoreProfile(e.data.pubkey, e.data.profile);
|
||||
break;
|
||||
|
||||
case 'getAllCachedProfiles':
|
||||
await handleGetAllCachedProfiles(requestId, port);
|
||||
void handleGetAllCachedProfiles(requestId, port);
|
||||
break;
|
||||
|
||||
case 'getUserSettings':
|
||||
await handleGetUserSettings(requestId, port);
|
||||
void handleGetUserSettings(requestId, port);
|
||||
break;
|
||||
|
||||
case 'patchUserSettings':
|
||||
await handlePatchUserSettings(requestId, patch, options, port);
|
||||
void handlePatchUserSettings(requestId, patch, options, port);
|
||||
break;
|
||||
|
||||
case 'setUserSettings':
|
||||
await handleSetUserSettings(requestId, settings, options, port);
|
||||
void handleSetUserSettings(requestId, settings, options, port);
|
||||
break;
|
||||
|
||||
case 'resetUserSettings':
|
||||
await handleResetUserSettings(requestId, options, port);
|
||||
void handleResetUserSettings(requestId, options, port);
|
||||
break;
|
||||
|
||||
case 'encryptContent':
|
||||
await handleEncryptContent(requestId, e.data.recipientPubkey, e.data.plaintext, e.data.scheme, port);
|
||||
void handleEncryptContent(requestId, e.data.recipientPubkey, e.data.plaintext, e.data.scheme, port);
|
||||
break;
|
||||
|
||||
case 'decryptContent':
|
||||
await handleDecryptContent(requestId, e.data.senderPubkey, e.data.ciphertext, e.data.scheme, port);
|
||||
void handleDecryptContent(requestId, e.data.senderPubkey, e.data.ciphertext, e.data.scheme, port);
|
||||
break;
|
||||
|
||||
case 'walletPublishMintList':
|
||||
await handleWalletPublishMintList(requestId, relays, receiveMints, port);
|
||||
void handleWalletPublishMintList(requestId, relays, receiveMints, port);
|
||||
break;
|
||||
|
||||
case 'walletFetchMintList':
|
||||
await handleWalletFetchMintList(requestId, targetPubkey, port);
|
||||
void handleWalletFetchMintList(requestId, targetPubkey, port);
|
||||
break;
|
||||
|
||||
case 'walletInit':
|
||||
await handleWalletInit(requestId, port);
|
||||
void handleWalletInit(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletStart':
|
||||
await handleWalletStart(requestId, pubkey, port);
|
||||
void handleWalletStart(requestId, pubkey, port);
|
||||
break;
|
||||
|
||||
case 'walletCreate':
|
||||
await handleWalletCreate(requestId, mints, relays, port);
|
||||
void handleWalletCreate(requestId, mints, relays, port);
|
||||
break;
|
||||
|
||||
case 'walletHasWallet':
|
||||
await handleWalletHasWallet(requestId, port);
|
||||
void handleWalletHasWallet(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletGetBalance':
|
||||
await handleWalletGetBalance(requestId, port);
|
||||
void handleWalletGetBalance(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletGetMints':
|
||||
await handleWalletGetMints(requestId, port);
|
||||
void handleWalletGetMints(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletReceiveToken':
|
||||
await handleWalletReceiveToken(requestId, token, description, port);
|
||||
void handleWalletReceiveToken(requestId, token, description, port);
|
||||
break;
|
||||
|
||||
case 'walletSendToken':
|
||||
await handleWalletSendToken(requestId, amount, memo, mint, port);
|
||||
void handleWalletSendToken(requestId, amount, memo, mint, port);
|
||||
break;
|
||||
|
||||
case 'walletSendNutzap':
|
||||
await handleWalletSendNutzap(
|
||||
void handleWalletSendNutzap(
|
||||
requestId,
|
||||
amount,
|
||||
memo,
|
||||
@@ -7087,23 +7116,23 @@ self.onconnect = (event) => {
|
||||
break;
|
||||
|
||||
case 'walletCreateDeposit':
|
||||
await handleWalletCreateDeposit(requestId, amount, mint, port);
|
||||
void handleWalletCreateDeposit(requestId, amount, mint, port);
|
||||
break;
|
||||
|
||||
case 'walletPayInvoice':
|
||||
await handleWalletPayInvoice(requestId, invoice, mint, port);
|
||||
void handleWalletPayInvoice(requestId, invoice, mint, port);
|
||||
break;
|
||||
|
||||
case 'walletAddMint':
|
||||
await handleWalletAddMint(requestId, mintUrl, port);
|
||||
void handleWalletAddMint(requestId, mintUrl, port);
|
||||
break;
|
||||
|
||||
case 'walletRemoveMint':
|
||||
await handleWalletRemoveMint(requestId, mintUrl, port);
|
||||
void handleWalletRemoveMint(requestId, mintUrl, port);
|
||||
break;
|
||||
|
||||
case 'walletGetTransactions':
|
||||
await handleWalletGetTransactions(requestId, port);
|
||||
void handleWalletGetTransactions(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletShutdown':
|
||||
@@ -7111,11 +7140,11 @@ self.onconnect = (event) => {
|
||||
break;
|
||||
|
||||
case 'walletCheckProofs':
|
||||
await handleWalletCheckProofs(requestId, port);
|
||||
void handleWalletCheckProofs(requestId, port);
|
||||
break;
|
||||
|
||||
case 'walletRepublish':
|
||||
await handleWalletRepublish(requestId, port);
|
||||
void handleWalletRepublish(requestId, port);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
@@ -257,9 +257,9 @@
|
||||
================================================================ -->
|
||||
<div id="divBody" class="clsBodyFull">
|
||||
<div id="divRelays">Loading relays...</div>
|
||||
<div id="divDiscoveredRelaysWrap" style="width:95%;margin:10px auto 0 auto;">
|
||||
<div id="divDiscoveredRelaysWrap" style="width:100%;margin:10px 0 0 0;overflow-x:auto;">
|
||||
<div id="divDiscoveredRelaysTitle" style="font-size:120%;margin-bottom:6px;cursor:pointer;user-select:none;">▸ Discovered Relays (Outbox)</div>
|
||||
<div id="divDiscoveredRelays" style="display:none;"></div>
|
||||
<div id="divDiscoveredRelays" style="display:none;max-height:300px;overflow-y:auto;"></div>
|
||||
</div>
|
||||
<div id="divRelayEventsWrap">
|
||||
<div id="divRelayEvents" class="relay-events-stream"></div>
|
||||
@@ -1361,27 +1361,38 @@ const versionInfo = await getVersion();
|
||||
return;
|
||||
}
|
||||
|
||||
// Filter out relays with no serving pubkeys — if no follows use this
|
||||
// relay, there's no reason to show it in the discovered relays list.
|
||||
const relaysWithFollows = relays.filter(r =>
|
||||
Array.isArray(r.servingPubkeys) && r.servingPubkeys.length > 0
|
||||
);
|
||||
|
||||
if (relaysWithFollows.length === 0) {
|
||||
container.innerHTML = '<div style="padding:8px;color:var(--muted-color);font-size:80%;">No discovered relays with active follow data. Load the feed page to populate outbox relays from your follows.</div>';
|
||||
return;
|
||||
}
|
||||
|
||||
let html = '<table style="width:100%;font-size:70%;border-collapse:collapse;">';
|
||||
html += '<thead><tr>';
|
||||
html += '<th class="tblCol tblColLeft" style="border:0.1px solid var(--muted-color);padding:4px;">Relay</th>';
|
||||
html += '<th class="tblCol tblColCenter" style="border:0.1px solid var(--muted-color);padding:4px;">Connected</th>';
|
||||
html += '<th class="tblCol tblColRight" style="border:0.1px solid var(--muted-color);padding:4px;">Serving</th>';
|
||||
html += '<th class="tblCol tblColLeft" style="border:0.1px solid var(--muted-color);padding:4px;">Sample Follows</th>';
|
||||
html += '<th class="tblCol tblColLeft" style="border:0.1px solid var(--muted-color);padding:4px;">Follows</th>';
|
||||
html += '</tr></thead><tbody>';
|
||||
|
||||
for (const relay of relays) {
|
||||
for (const relay of relaysWithFollows) {
|
||||
const connected = relay.connected ? SVG_CHECKED : SVG_UNCHECKED;
|
||||
const servingCount = Array.isArray(relay.servingPubkeys) ? relay.servingPubkeys.length : 0;
|
||||
const sampleFollows = Array.isArray(relay.servingPubkeys)
|
||||
? relay.servingPubkeys.slice(0, 3).map(shortNpub).join(', ')
|
||||
: '-';
|
||||
const followsList = Array.isArray(relay.servingNames) && relay.servingNames.length > 0
|
||||
? relay.servingNames.join(', ')
|
||||
: (Array.isArray(relay.servingPubkeys) ? relay.servingPubkeys.map(shortNpub).join(', ') : '-');
|
||||
const rowClass = relay.connected ? 'tblRowConnected' : '';
|
||||
|
||||
html += `<tr class="${rowClass}">`;
|
||||
html += `<td class="tblCol tblColLeft tblColRelay" style="border:0.1px solid var(--muted-color);padding:4px;" title="${relay.url}">${relay.url}</td>`;
|
||||
html += `<td class="tblCol tblColCenter" style="border:0.1px solid var(--muted-color);padding:4px;">${connected}</td>`;
|
||||
html += `<td class="tblCol tblColRight" style="border:0.1px solid var(--muted-color);padding:4px;">${servingCount}</td>`;
|
||||
html += `<td class="tblCol tblColLeft" style="border:0.1px solid var(--muted-color);padding:4px;font-family:monospace;">${sampleFollows}</td>`;
|
||||
html += `<td class="tblCol tblColLeft" style="border:0.1px solid var(--muted-color);padding:4px;font-family:monospace;word-break:break-all;">${followsList}</td>`;
|
||||
html += '</tr>';
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user