431 lines
12 KiB
TypeScript
431 lines
12 KiB
TypeScript
import { BIG_RELAY_URLS, MAX_PINNED_NOTES, POLL_TYPE } from '@/constants'
|
|
import { TEmoji, TPollType, TRelayList, TRelaySet } from '@/types'
|
|
import { Event, kinds } from 'nostr-tools'
|
|
import { buildATag } from './draft-event'
|
|
import { getReplaceableEventIdentifier } from './event'
|
|
import { getAmountFromInvoice, getLightningAddressFromProfile } from './lightning'
|
|
import { formatPubkey, isValidPubkey, pubkeyToNpub } from './pubkey'
|
|
import { generateBech32IdFromETag, getEmojiInfosFromEmojiTags, tagNameEquals } from './tag'
|
|
import { isOnionUrl, isWebsocketUrl, normalizeHttpUrl, normalizeUrl } from './url'
|
|
|
|
export function getRelayListFromEvent(
|
|
event?: Event | null,
|
|
filterOutOnionRelays: boolean = true
|
|
): TRelayList {
|
|
if (!event) {
|
|
return { write: BIG_RELAY_URLS, read: BIG_RELAY_URLS, originalRelays: [] }
|
|
}
|
|
|
|
const relayList = { write: [], read: [], originalRelays: [] } as TRelayList
|
|
event.tags.filter(tagNameEquals('r')).forEach(([, url, type]) => {
|
|
if (!url || !isWebsocketUrl(url)) return
|
|
|
|
const normalizedUrl = normalizeUrl(url)
|
|
if (!normalizedUrl) return
|
|
|
|
const scope = type === 'read' ? 'read' : type === 'write' ? 'write' : 'both'
|
|
relayList.originalRelays.push({ url: normalizedUrl, scope })
|
|
|
|
if (filterOutOnionRelays && isOnionUrl(normalizedUrl)) return
|
|
|
|
if (type === 'write') {
|
|
relayList.write.push(normalizedUrl)
|
|
} else if (type === 'read') {
|
|
relayList.read.push(normalizedUrl)
|
|
} else {
|
|
relayList.write.push(normalizedUrl)
|
|
relayList.read.push(normalizedUrl)
|
|
}
|
|
})
|
|
|
|
// If there are too many relays, use the default BIG_RELAY_URLS
|
|
// Because they don't know anything about relays, their settings cannot be trusted
|
|
return {
|
|
write: relayList.write.length && relayList.write.length <= 8 ? relayList.write : BIG_RELAY_URLS,
|
|
read: relayList.read.length && relayList.write.length <= 8 ? relayList.read : BIG_RELAY_URLS,
|
|
originalRelays: relayList.originalRelays
|
|
}
|
|
}
|
|
|
|
export function getProfileFromEvent(event: Event) {
|
|
try {
|
|
const profileObj = JSON.parse(event.content)
|
|
const username =
|
|
profileObj.display_name?.trim() ||
|
|
profileObj.name?.trim() ||
|
|
profileObj.nip05?.split('@')[0]?.trim()
|
|
|
|
// Extract emojis from emoji tags according to NIP-30
|
|
const emojis = getEmojiInfosFromEmojiTags(event.tags)
|
|
|
|
return {
|
|
pubkey: event.pubkey,
|
|
npub: pubkeyToNpub(event.pubkey) ?? '',
|
|
banner: profileObj.banner,
|
|
avatar: profileObj.picture,
|
|
username: username || formatPubkey(event.pubkey),
|
|
original_username: username,
|
|
nip05: profileObj.nip05,
|
|
about: profileObj.about,
|
|
website: profileObj.website ? normalizeHttpUrl(profileObj.website) : undefined,
|
|
lud06: profileObj.lud06,
|
|
lud16: profileObj.lud16,
|
|
lightningAddress: getLightningAddressFromProfile(profileObj),
|
|
created_at: event.created_at,
|
|
emojis: emojis.length > 0 ? emojis : undefined
|
|
}
|
|
} catch (err) {
|
|
console.error(event.content, err)
|
|
return {
|
|
pubkey: event.pubkey,
|
|
npub: pubkeyToNpub(event.pubkey) ?? '',
|
|
username: formatPubkey(event.pubkey)
|
|
}
|
|
}
|
|
}
|
|
|
|
export function getRelaySetFromEvent(event: Event): TRelaySet {
|
|
const id = getReplaceableEventIdentifier(event)
|
|
const relayUrls = event.tags
|
|
.filter(tagNameEquals('relay'))
|
|
.map((tag) => tag[1])
|
|
.filter((url) => url && isWebsocketUrl(url))
|
|
.map((url) => normalizeUrl(url))
|
|
|
|
let name = event.tags.find(tagNameEquals('title'))?.[1]
|
|
if (!name) {
|
|
name = id
|
|
}
|
|
|
|
return { id, name, relayUrls, aTag: buildATag(event) }
|
|
}
|
|
|
|
export function getZapInfoFromEvent(receiptEvent: Event) {
|
|
if (receiptEvent.kind !== kinds.Zap) return null
|
|
|
|
let senderPubkey: string | undefined
|
|
let recipientPubkey: string | undefined
|
|
let originalEventId: string | undefined
|
|
let eventId: string | undefined
|
|
let invoice: string | undefined
|
|
let amount: number | undefined
|
|
let comment: string | undefined
|
|
let description: string | undefined
|
|
let preimage: string | undefined
|
|
try {
|
|
receiptEvent.tags.forEach((tag) => {
|
|
const [tagName, tagValue] = tag
|
|
switch (tagName) {
|
|
case 'P':
|
|
senderPubkey = tagValue
|
|
break
|
|
case 'p':
|
|
recipientPubkey = tagValue
|
|
break
|
|
case 'e':
|
|
originalEventId = tag[1]
|
|
eventId = generateBech32IdFromETag(tag)
|
|
break
|
|
case 'bolt11':
|
|
invoice = tagValue
|
|
break
|
|
case 'description':
|
|
description = tagValue
|
|
break
|
|
case 'preimage':
|
|
preimage = tagValue
|
|
break
|
|
}
|
|
})
|
|
if (!recipientPubkey || !invoice) return null
|
|
amount = invoice ? getAmountFromInvoice(invoice) : 0
|
|
if (description) {
|
|
try {
|
|
const zapRequest = JSON.parse(description)
|
|
comment = zapRequest.content
|
|
if (!senderPubkey) {
|
|
senderPubkey = zapRequest.pubkey
|
|
}
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
return {
|
|
senderPubkey,
|
|
recipientPubkey,
|
|
eventId,
|
|
originalEventId,
|
|
invoice,
|
|
amount,
|
|
comment,
|
|
preimage
|
|
}
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function getLongFormArticleMetadataFromEvent(event: Event) {
|
|
let title: string | undefined
|
|
let summary: string | undefined
|
|
let image: string | undefined
|
|
const tags = new Set<string>()
|
|
|
|
event.tags.forEach(([tagName, tagValue]) => {
|
|
if (tagName === 'title') {
|
|
title = tagValue
|
|
} else if (tagName === 'summary') {
|
|
summary = tagValue
|
|
} else if (tagName === 'image') {
|
|
image = tagValue
|
|
} else if (tagName === 't' && tagValue && tags.size < 6) {
|
|
tags.add(tagValue.toLocaleLowerCase())
|
|
}
|
|
})
|
|
|
|
if (!title) {
|
|
title = event.tags.find(tagNameEquals('d'))?.[1] ?? 'no title'
|
|
}
|
|
|
|
return { title, summary, image, tags: Array.from(tags) }
|
|
}
|
|
|
|
export function getLiveEventMetadataFromEvent(event: Event) {
|
|
let title: string | undefined
|
|
let summary: string | undefined
|
|
let image: string | undefined
|
|
let status: string | undefined
|
|
const tags = new Set<string>()
|
|
|
|
event.tags.forEach(([tagName, tagValue]) => {
|
|
if (tagName === 'title') {
|
|
title = tagValue
|
|
} else if (tagName === 'summary') {
|
|
summary = tagValue
|
|
} else if (tagName === 'image') {
|
|
image = tagValue
|
|
} else if (tagName === 'status') {
|
|
status = tagValue
|
|
} else if (tagName === 't' && tagValue && tags.size < 6) {
|
|
tags.add(tagValue.toLocaleLowerCase())
|
|
}
|
|
})
|
|
|
|
if (!title) {
|
|
title = event.tags.find(tagNameEquals('d'))?.[1] ?? 'no title'
|
|
}
|
|
|
|
return { title, summary, image, status, tags: Array.from(tags) }
|
|
}
|
|
|
|
export function getGroupMetadataFromEvent(event: Event) {
|
|
let d: string | undefined
|
|
let name: string | undefined
|
|
let about: string | undefined
|
|
let picture: string | undefined
|
|
const tags = new Set<string>()
|
|
|
|
event.tags.forEach(([tagName, tagValue]) => {
|
|
if (tagName === 'name') {
|
|
name = tagValue
|
|
} else if (tagName === 'about') {
|
|
about = tagValue
|
|
} else if (tagName === 'picture') {
|
|
picture = tagValue
|
|
} else if (tagName === 't' && tagValue) {
|
|
tags.add(tagValue.toLocaleLowerCase())
|
|
} else if (tagName === 'd') {
|
|
d = tagValue
|
|
}
|
|
})
|
|
|
|
if (!name) {
|
|
name = d ?? 'no name'
|
|
}
|
|
|
|
return { d, name, about, picture, tags: Array.from(tags) }
|
|
}
|
|
|
|
export function getCommunityDefinitionFromEvent(event: Event) {
|
|
let name: string | undefined
|
|
let description: string | undefined
|
|
let image: string | undefined
|
|
|
|
event.tags.forEach(([tagName, tagValue]) => {
|
|
if (tagName === 'name') {
|
|
name = tagValue
|
|
} else if (tagName === 'description') {
|
|
description = tagValue
|
|
} else if (tagName === 'image') {
|
|
image = tagValue
|
|
}
|
|
})
|
|
|
|
if (!name) {
|
|
name = event.tags.find(tagNameEquals('d'))?.[1] ?? 'no name'
|
|
}
|
|
|
|
return { name, description, image }
|
|
}
|
|
|
|
export function getPollMetadataFromEvent(event: Event) {
|
|
const options: { id: string; label: string }[] = []
|
|
const relayUrls: string[] = []
|
|
let pollType: TPollType = POLL_TYPE.SINGLE_CHOICE
|
|
let endsAt: number | undefined
|
|
|
|
for (const [tagName, ...tagValues] of event.tags) {
|
|
if (tagName === 'option' && tagValues.length >= 2) {
|
|
const [optionId, label] = tagValues
|
|
if (optionId && label) {
|
|
options.push({ id: optionId, label })
|
|
}
|
|
} else if (tagName === 'relay' && tagValues[0]) {
|
|
const normalizedUrl = normalizeUrl(tagValues[0])
|
|
if (normalizedUrl) relayUrls.push(tagValues[0])
|
|
} else if (tagName === 'polltype' && tagValues[0]) {
|
|
if (tagValues[0] === POLL_TYPE.MULTIPLE_CHOICE) {
|
|
pollType = POLL_TYPE.MULTIPLE_CHOICE
|
|
}
|
|
} else if (tagName === 'endsAt' && tagValues[0]) {
|
|
const timestamp = parseInt(tagValues[0])
|
|
if (!isNaN(timestamp)) {
|
|
endsAt = timestamp
|
|
}
|
|
}
|
|
}
|
|
|
|
if (options.length === 0) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
options,
|
|
pollType,
|
|
relayUrls,
|
|
endsAt
|
|
}
|
|
}
|
|
|
|
export function getPollResponseFromEvent(
|
|
event: Event,
|
|
optionIds: string[],
|
|
isMultipleChoice: boolean
|
|
) {
|
|
const selectedOptionIds: string[] = []
|
|
|
|
for (const [tagName, ...tagValues] of event.tags) {
|
|
if (tagName === 'response' && tagValues[0]) {
|
|
if (optionIds && !optionIds.includes(tagValues[0])) {
|
|
continue // Skip if the response is not in the provided optionIds
|
|
}
|
|
selectedOptionIds.push(tagValues[0])
|
|
}
|
|
}
|
|
|
|
// If no valid responses are found, return null
|
|
if (selectedOptionIds.length === 0) {
|
|
return null
|
|
}
|
|
|
|
// If multiple responses are selected but the poll is not multiple choice, return null
|
|
if (selectedOptionIds.length > 1 && !isMultipleChoice) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
id: event.id,
|
|
pubkey: event.pubkey,
|
|
selectedOptionIds,
|
|
created_at: event.created_at
|
|
}
|
|
}
|
|
|
|
export function getEmojisAndEmojiSetsFromEvent(event: Event) {
|
|
const emojis: TEmoji[] = []
|
|
const emojiSetPointers: string[] = []
|
|
|
|
event.tags.forEach(([tagName, ...tagValues]) => {
|
|
if (tagName === 'emoji' && tagValues.length >= 2) {
|
|
emojis.push({
|
|
shortcode: tagValues[0],
|
|
url: tagValues[1]
|
|
})
|
|
} else if (tagName === 'a' && tagValues[0]) {
|
|
emojiSetPointers.push(tagValues[0])
|
|
}
|
|
})
|
|
|
|
return { emojis, emojiSetPointers }
|
|
}
|
|
|
|
export function getEmojiPackInfoFromEvent(event: Event) {
|
|
let title: string | undefined
|
|
const emojis: TEmoji[] = []
|
|
|
|
event.tags.forEach(([tagName, ...tagValues]) => {
|
|
if (tagName === 'title' && tagValues[0]) {
|
|
title = tagValues[0]
|
|
} else if (tagName === 'emoji' && tagValues.length >= 2) {
|
|
emojis.push({
|
|
shortcode: tagValues[0],
|
|
url: tagValues[1]
|
|
})
|
|
}
|
|
})
|
|
|
|
return { title, emojis }
|
|
}
|
|
|
|
export function getEmojisFromEvent(event: Event): TEmoji[] {
|
|
const info = getEmojiPackInfoFromEvent(event)
|
|
return info.emojis
|
|
}
|
|
|
|
export function getStarsFromRelayReviewEvent(event: Event): number {
|
|
const ratingTag = event.tags.find((t) => t[0] === 'rating')
|
|
if (ratingTag) {
|
|
const stars = parseFloat(ratingTag[1]) * 5
|
|
if (stars > 0 && stars <= 5) {
|
|
return stars
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
export function getPinnedEventHexIdSetFromPinListEvent(event?: Event | null): Set<string> {
|
|
return new Set(
|
|
event?.tags
|
|
.filter((tag) => tag[0] === 'e')
|
|
.map((tag) => tag[1])
|
|
.reverse()
|
|
.slice(0, MAX_PINNED_NOTES) ?? []
|
|
)
|
|
}
|
|
|
|
export function getFollowPackInfoFromEvent(event: Event) {
|
|
let title: string | undefined
|
|
let description: string | undefined
|
|
let image: string | undefined
|
|
const pubkeys: string[] = []
|
|
|
|
event.tags.forEach(([tagName, tagValue]) => {
|
|
if (tagName === 'title') {
|
|
title = tagValue
|
|
} else if (tagName === 'description') {
|
|
description = tagValue
|
|
} else if (tagName === 'image') {
|
|
image = tagValue
|
|
} else if (tagName === 'p' && isValidPubkey(tagValue)) {
|
|
pubkeys.push(tagValue)
|
|
}
|
|
})
|
|
|
|
if (!title) {
|
|
title = event.tags.find(tagNameEquals('d'))?.[1] ?? 'Untitled Follow Pack'
|
|
}
|
|
|
|
return { title, description, image, pubkeys }
|
|
}
|