diff --git a/packages/app/src/zappers.ts b/packages/app/src/zappers.ts index e7896eb..3fc51ff 100644 --- a/packages/app/src/zappers.ts +++ b/packages/app/src/zappers.ts @@ -1,7 +1,7 @@ import {writable, derived} from "svelte/store" -import {Zapper} from "@welshman/util" +import {Zapper, TrustedEvent, Zap, getTagValues, getLnUrl, zapFromEvent} from "@welshman/util" import { - identity, + removeNil, fetchJson, uniq, bech32ToHex, @@ -11,7 +11,7 @@ import { postJson, } from "@welshman/lib" import {collection} from "@welshman/store" -import {deriveProfile} from "./profiles.js" +import {deriveProfile, loadProfile} from "./profiles.js" import {appContext} from "./context.js" export const zappers = writable([]) @@ -22,7 +22,7 @@ export const fetchZappers = async (lnurls: string[]) => { // Use dufflepud if we it's set up to protect user privacy, otherwise fetch directly if (base) { - const hexUrls = lnurls.map(lnurl => tryCatch(() => bech32ToHex(lnurl))).filter(identity) + const hexUrls = removeNil(lnurls.map(lnurl => tryCatch(() => bech32ToHex(lnurl)))) if (hexUrls.length > 0) { const res: any = await tryCatch( @@ -90,3 +90,40 @@ export const deriveZapperForPubkey = (pubkey: string, relays: string[] = []) => return $zappersByLnurl.get($profile.lnurl) }) + +export const getLnUrlsForEvent = async (event: TrustedEvent) => { + const lnurls = removeNil(getTagValues("zap", event.tags).map(getLnUrl)) + + if (lnurls.length > 0) { + return lnurls + } + + const profile = await loadProfile(event.pubkey) + + return removeNil([profile?.lnurl]) +} + +export const getZapperForZap = async (zap: TrustedEvent, parent: TrustedEvent) => { + const lnurls = await getLnUrlsForEvent(parent) + + return lnurls.length > 0 ? loadZapper(lnurls[0]) : undefined +} + +export const getValidZap = async (zap: TrustedEvent, parent: TrustedEvent) => { + const zapper = await getZapperForZap(zap, parent) + + return zapper ? zapFromEvent(zap, zapper) : undefined +} + +export const getValidZaps = async (zaps: TrustedEvent[], parent: TrustedEvent) => + removeNil(await Promise.all(zaps.map(zap => getValidZap(zap, parent)))) + +export const deriveValidZaps = (zaps: TrustedEvent[], parent: TrustedEvent) => { + const store = writable([]) + + getValidZaps(zaps, parent).then(validZaps => { + store.set(validZaps) + }) + + return store +} diff --git a/packages/store/src/repository.ts b/packages/store/src/repository.ts index 397296f..a729eb0 100644 --- a/packages/store/src/repository.ts +++ b/packages/store/src/repository.ts @@ -1,12 +1,12 @@ import {derived} from "svelte/store" -import {sortBy, identity, ensurePlural, batch, partition, first} from "@welshman/lib" +import {sortBy, identity, ensurePlural, removeNil, batch, partition, first} from "@welshman/lib" import {Repository} from "@welshman/relay" import {matchFilters, getIdAndAddress, getIdFilters, Filter, TrustedEvent} from "@welshman/util" import {custom} from "./custom.js" export type DeriveEventsMappedOptions = { filters: Filter[] - eventToItem: (event: TrustedEvent) => T | T[] | Promise | undefined + eventToItem: (event: TrustedEvent) => undefined | T | T[] | Promise itemToEvent: (item: T) => TrustedEvent throttle?: number includeDeleted?: boolean @@ -27,14 +27,14 @@ export const deriveEventsMapped = ( let data: T[] = [] const deferred = new Set() - const defer = (event: TrustedEvent, promise: Promise) => { + const defer = (event: TrustedEvent, promise: Promise) => { deferred.add(event.id) void promise.then(items => { if (deferred.has(event.id)) { deferred.delete(event.id) - for (const item of ensurePlural(items)) { + for (const item of removeNil(ensurePlural(items))) { data.push(item) } @@ -53,7 +53,7 @@ export const deriveEventsMapped = ( if (items instanceof Promise) { defer(event, items) } else { - for (const item of ensurePlural(items)) { + for (const item of removeNil(ensurePlural(items))) { data.push(item) } } @@ -89,7 +89,7 @@ export const deriveEventsMapped = ( } else if (items) { dirty = true - for (const item of ensurePlural(items)) { + for (const item of removeNil(ensurePlural(items))) { data.push(item as T) } } diff --git a/packages/util/__tests__/Zaps.test.ts b/packages/util/__tests__/Zaps.test.ts index d788430..e8b8b84 100644 --- a/packages/util/__tests__/Zaps.test.ts +++ b/packages/util/__tests__/Zaps.test.ts @@ -75,7 +75,7 @@ describe("Zaps", () => { }) it("should return null for invalid input", () => { - expect(getLnUrl("invalid")).toBeNull() + expect(getLnUrl("invalid")).toBeUndefined() }) }) @@ -138,7 +138,7 @@ describe("Zaps", () => { const result = zapFromEvent(response, validZapper) - expect(result).toBeNull() + expect(result).toBeUndefined() }) it("should reject amount mismatch", () => { @@ -150,7 +150,7 @@ describe("Zaps", () => { const result = zapFromEvent(response, validZapper) - expect(result).toBeNull() + expect(result).toBeUndefined() }) it("should reject incorrect zapper pubkey", () => { @@ -160,7 +160,7 @@ describe("Zaps", () => { const result = zapFromEvent(response, validZapper) - expect(result).toBeNull() + expect(result).toBeUndefined() }) it("should reject incorrect lnurl", () => { @@ -172,7 +172,7 @@ describe("Zaps", () => { const result = zapFromEvent(response, validZapper) - expect(result).toBeNull() + expect(result).toBeUndefined() }) it("should handle invalid description JSON", () => { @@ -183,7 +183,7 @@ describe("Zaps", () => { const result = zapFromEvent(response, validZapper) - expect(result).toBeNull() + expect(result).toBeUndefined() }) it("should accept zap when recipient is zapper", () => { diff --git a/packages/util/src/Zaps.ts b/packages/util/src/Zaps.ts index 096f537..3cb1f1e 100644 --- a/packages/util/src/Zaps.ts +++ b/packages/util/src/Zaps.ts @@ -1,5 +1,9 @@ -import {hexToBech32, fromPairs} from "@welshman/lib" -import type {TrustedEvent} from "./Events.js" +import {now, tryCatch, fetchJson, hexToBech32, fromPairs} from "@welshman/lib" +import {ZAP_RESPONSE, ZAP_REQUEST} from "./Kinds.js" +import {getTagValue} from "./Tags.js" +import type {Filter} from "./Filters.js" +import type {TrustedEvent, SignedEvent} from "./Events.js" +import {makeEvent} from "./Events.js" const DIVISORS = { m: BigInt(1e3), @@ -12,6 +16,10 @@ const MAX_MILLISATS = BigInt("2100000000000000000") const MILLISATS_PER_BTC = BigInt(1e11) +export const toMsats = (sats: number) => sats * 1000 + +export const fromMsats = (msats: number) => Math.floor(msats / 1000) + export const hrpToMillisat = (hrpString: string) => { let divisor, value if (hrpString.slice(-1).match(/^[munp]$/)) { @@ -68,7 +76,7 @@ export const getLnUrl = (address: string) => { } } - return null + return undefined } export type Zapper = { @@ -98,19 +106,19 @@ export const zapFromEvent = (response: TrustedEvent, zapper: Zapper | undefined) request: JSON.parse(responseMeta.description), } } catch (e) { - return null + return undefined } // Don't count zaps that the user requested for himself if (zap.request.pubkey === zapper?.pubkey) { - return null + return undefined } const {amount, lnurl} = fromPairs(zap.request.tags) // Verify that the zapper actually sent the requested amount (if it was supplied) if (amount && parseInt(amount) !== zap.invoiceAmount) { - return null + return undefined } // If the recipient and the zapper are the same person, it's legit @@ -120,13 +128,89 @@ export const zapFromEvent = (response: TrustedEvent, zapper: Zapper | undefined) // If the sending client provided an lnurl tag, verify that too if (lnurl && lnurl !== zapper?.lnurl) { - return null + return undefined } // Verify that the request actually came from the recipient's zapper if (zap.response.pubkey !== zapper?.nostrPubkey) { - return null + return undefined } return zap } + +export type ZapRequestParams = { + msats: number + zapper: Zapper + pubkey: string + relays: string[] + content?: string + eventId?: string + anonymous?: boolean +} + +export const makeZapRequest = ({ + msats, + zapper, + pubkey, + relays, + content = "", + eventId, + anonymous, +}: ZapRequestParams) => { + const tags = [ + ["relays", ...relays], + ["amount", String(msats)], + ["lnurl", zapper.lnurl], + ["p", pubkey], + ] + + if (eventId) { + tags.push(["e", eventId]) + } + + if (anonymous) { + tags.push(["anon"]) + } + + return makeEvent(ZAP_REQUEST, {content, tags}) +} + +export type RequestInvoiceParams = { + zapper: Zapper + event: SignedEvent +} + +export const requestZap = async ({zapper, event}: RequestInvoiceParams) => { + const zapString = encodeURI(JSON.stringify(event)) + const msats = parseInt(getTagValue("amount", event.tags)!) + const qs = `?amount=${msats}&nostr=${zapString}&lnurl=${zapper.lnurl}` + const res = await tryCatch(() => fetchJson(zapper.callback + qs)) + + return res?.pr ? {invoice: res.pr} : {error: res.reason || "Failed to request invoice"} +} + +export type ZapResponseFilterParams = { + zapper: Zapper + pubkey: string + eventId?: string +} + +export const getZapResponseFilter = ({zapper, pubkey, eventId}: ZapResponseFilterParams) => { + if (!zapper.nostrPubkey) { + throw new Error("Zapper did not have a nostr pubkey") + } + + const filter: Filter = { + kinds: [ZAP_RESPONSE], + authors: [zapper.nostrPubkey], + since: now() - 30, + "#p": [pubkey], + } + + if (eventId) { + filter["#e"] = [eventId] + } + + return filter +}