399 lines
12 KiB
TypeScript
399 lines
12 KiB
TypeScript
import { useMemo } from "react";
|
|
import { useSelector } from "react-redux";
|
|
import * as secp from "@noble/secp256k1";
|
|
import { EventKind, RelaySettings, TaggedRawEvent, HexKey, RawEvent, u256, UserMetadata, Lists } from "@snort/nostr";
|
|
|
|
import { RootState } from "State/Store";
|
|
import { bech32ToHex, delay, unwrap } from "Util";
|
|
import { DefaultRelays, HashtagRegex } from "Const";
|
|
import { System } from "System";
|
|
import { EventExt } from "System/EventExt";
|
|
|
|
declare global {
|
|
interface Window {
|
|
nostr: {
|
|
getPublicKey: () => Promise<HexKey>;
|
|
signEvent: (event: RawEvent) => Promise<RawEvent>;
|
|
getRelays: () => Promise<Record<string, { read: boolean; write: boolean }>>;
|
|
nip04: {
|
|
encrypt: (pubkey: HexKey, content: string) => Promise<string>;
|
|
decrypt: (pubkey: HexKey, content: string) => Promise<string>;
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
export type EventPublisher = ReturnType<typeof useEventPublisher>;
|
|
|
|
export default function useEventPublisher() {
|
|
const pubKey = useSelector<RootState, HexKey | undefined>(s => s.login.publicKey);
|
|
const privKey = useSelector<RootState, HexKey | undefined>(s => s.login.privateKey);
|
|
const follows = useSelector<RootState, HexKey[]>(s => s.login.follows);
|
|
const relays = useSelector((s: RootState) => s.login.relays);
|
|
const hasNip07 = "nostr" in window;
|
|
|
|
async function signEvent(ev: RawEvent): Promise<RawEvent> {
|
|
if (hasNip07 && !privKey) {
|
|
ev.id = await EventExt.createId(ev);
|
|
const tmpEv = (await barrierNip07(() => window.nostr.signEvent(ev))) as RawEvent;
|
|
ev.sig = tmpEv.sig;
|
|
return ev;
|
|
} else if (privKey) {
|
|
await EventExt.sign(ev, privKey);
|
|
} else {
|
|
console.warn("Count not sign event, no private keys available");
|
|
}
|
|
return ev;
|
|
}
|
|
|
|
function processContent(ev: RawEvent, msg: string) {
|
|
const replaceNpub = (match: string) => {
|
|
const npub = match.slice(1);
|
|
try {
|
|
const hex = bech32ToHex(npub);
|
|
const idx = ev.tags.length;
|
|
ev.tags.push(["p", hex]);
|
|
return `#[${idx}]`;
|
|
} catch (error) {
|
|
return match;
|
|
}
|
|
};
|
|
const replaceNoteId = (match: string) => {
|
|
const noteId = match.slice(1);
|
|
try {
|
|
const hex = bech32ToHex(noteId);
|
|
const idx = ev.tags.length;
|
|
ev.tags.push(["e", hex, "", "mention"]);
|
|
return `#[${idx}]`;
|
|
} catch (error) {
|
|
return match;
|
|
}
|
|
};
|
|
const replaceHashtag = (match: string) => {
|
|
const tag = match.slice(1);
|
|
ev.tags.push(["t", tag.toLowerCase()]);
|
|
return match;
|
|
};
|
|
const content = msg
|
|
.replace(/@npub[a-z0-9]+/g, replaceNpub)
|
|
.replace(/@note1[acdefghjklmnpqrstuvwxyz023456789]{58}/g, replaceNoteId)
|
|
.replace(HashtagRegex, replaceHashtag);
|
|
ev.content = content;
|
|
}
|
|
|
|
const ret = {
|
|
nip42Auth: async (challenge: string, relay: string) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.Auth);
|
|
ev.tags.push(["relay", relay]);
|
|
ev.tags.push(["challenge", challenge]);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
broadcast: (ev: RawEvent | undefined) => {
|
|
if (ev) {
|
|
console.debug("Sending event: ", ev);
|
|
System.BroadcastEvent(ev);
|
|
}
|
|
},
|
|
/**
|
|
* Write event to DefaultRelays, this is important for profiles / relay lists to prevent bugs
|
|
* If a user removes all the DefaultRelays from their relay list and saves that relay list,
|
|
* When they open the site again we wont see that updated relay list and so it will appear to reset back to the previous state
|
|
*/
|
|
broadcastForBootstrap: (ev: RawEvent | undefined) => {
|
|
if (ev) {
|
|
for (const [k] of DefaultRelays) {
|
|
System.WriteOnceToRelay(k, ev);
|
|
}
|
|
}
|
|
},
|
|
/**
|
|
* Write event to all given relays.
|
|
*/
|
|
broadcastAll: (ev: RawEvent | undefined, relays: string[]) => {
|
|
if (ev) {
|
|
for (const k of relays) {
|
|
System.WriteOnceToRelay(k, ev);
|
|
}
|
|
}
|
|
},
|
|
muted: async (keys: HexKey[], priv: HexKey[]) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.PubkeyLists);
|
|
ev.tags.push(["d", Lists.Muted]);
|
|
keys.forEach(p => {
|
|
ev.tags.push(["p", p]);
|
|
});
|
|
let content = "";
|
|
if (priv.length > 0) {
|
|
const ps = priv.map(p => ["p", p]);
|
|
const plaintext = JSON.stringify(ps);
|
|
if (hasNip07 && !privKey) {
|
|
content = await barrierNip07(() => window.nostr.nip04.encrypt(pubKey, plaintext));
|
|
} else if (privKey) {
|
|
content = await EventExt.encryptData(plaintext, pubKey, privKey);
|
|
}
|
|
}
|
|
ev.content = content;
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
pinned: async (notes: HexKey[]) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.NoteLists);
|
|
ev.tags.push(["d", Lists.Pinned]);
|
|
notes.forEach(n => {
|
|
ev.tags.push(["e", n]);
|
|
});
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
bookmarked: async (notes: HexKey[]) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.NoteLists);
|
|
ev.tags.push(["d", Lists.Bookmarked]);
|
|
notes.forEach(n => {
|
|
ev.tags.push(["e", n]);
|
|
});
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
tags: async (tags: string[]) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.TagLists);
|
|
ev.tags.push(["d", Lists.Followed]);
|
|
tags.forEach(t => {
|
|
ev.tags.push(["t", t]);
|
|
});
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
metadata: async (obj: UserMetadata) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.SetMetadata);
|
|
ev.content = JSON.stringify(obj);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
note: async (msg: string) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.TextNote);
|
|
processContent(ev, msg);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
zap: async (amount: number, author: HexKey, note?: HexKey, msg?: string) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.ZapRequest);
|
|
if (note) {
|
|
ev.tags.push(["e", note]);
|
|
}
|
|
ev.tags.push(["p", author]);
|
|
const relayTag = ["relays", ...Object.keys(relays).map(a => a.trim())];
|
|
ev.tags.push(relayTag);
|
|
ev.tags.push(["amount", amount.toString()]);
|
|
processContent(ev, msg || "");
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
/**
|
|
* Reply to a note
|
|
*/
|
|
reply: async (replyTo: TaggedRawEvent, msg: string) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.TextNote);
|
|
|
|
const thread = EventExt.extractThread(ev);
|
|
if (thread) {
|
|
if (thread.root || thread.replyTo) {
|
|
ev.tags.push(["e", thread.root?.Event ?? thread.replyTo?.Event ?? "", "", "root"]);
|
|
}
|
|
ev.tags.push(["e", replyTo.id, replyTo.relays[0] ?? "", "reply"]);
|
|
|
|
// dont tag self in replies
|
|
if (replyTo.pubkey !== pubKey) {
|
|
ev.tags.push(["p", replyTo.pubkey]);
|
|
}
|
|
|
|
for (const pk of thread.pubKeys) {
|
|
if (pk === pubKey) {
|
|
continue; // dont tag self in replies
|
|
}
|
|
ev.tags.push(["p", pk]);
|
|
}
|
|
} else {
|
|
ev.tags.push(["e", replyTo.id, "", "reply"]);
|
|
// dont tag self in replies
|
|
if (replyTo.pubkey !== pubKey) {
|
|
ev.tags.push(["p", replyTo.pubkey]);
|
|
}
|
|
}
|
|
processContent(ev, msg);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
react: async (evRef: RawEvent, content = "+") => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.Reaction);
|
|
ev.content = content;
|
|
ev.tags.push(["e", evRef.id]);
|
|
ev.tags.push(["p", evRef.pubkey]);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
saveRelays: async () => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.ContactList);
|
|
ev.content = JSON.stringify(relays);
|
|
for (const pk of follows) {
|
|
ev.tags.push(["p", pk]);
|
|
}
|
|
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
saveRelaysSettings: async () => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.Relays);
|
|
for (const [url, settings] of Object.entries(relays)) {
|
|
const rTag = ["r", url];
|
|
if (settings.read && !settings.write) {
|
|
rTag.push("read");
|
|
}
|
|
if (settings.write && !settings.read) {
|
|
rTag.push("write");
|
|
}
|
|
ev.tags.push(rTag);
|
|
}
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
addFollow: async (pkAdd: HexKey | HexKey[], newRelays?: Record<string, RelaySettings>) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.ContactList);
|
|
ev.content = JSON.stringify(newRelays ?? relays);
|
|
const temp = new Set(follows);
|
|
if (Array.isArray(pkAdd)) {
|
|
pkAdd.forEach(a => temp.add(a));
|
|
} else {
|
|
temp.add(pkAdd);
|
|
}
|
|
for (const pk of temp) {
|
|
if (pk.length !== 64) {
|
|
continue;
|
|
}
|
|
ev.tags.push(["p", pk.toLowerCase()]);
|
|
}
|
|
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
removeFollow: async (pkRemove: HexKey) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.ContactList);
|
|
ev.content = JSON.stringify(relays);
|
|
for (const pk of follows) {
|
|
if (pk === pkRemove || pk.length !== 64) {
|
|
continue;
|
|
}
|
|
ev.tags.push(["p", pk]);
|
|
}
|
|
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
/**
|
|
* Delete an event (NIP-09)
|
|
*/
|
|
delete: async (id: u256) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.Deletion);
|
|
ev.tags.push(["e", id]);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
/**
|
|
* Repost a note (NIP-18)
|
|
*/
|
|
repost: async (note: TaggedRawEvent) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.Repost);
|
|
ev.tags.push(["e", note.id, ""]);
|
|
ev.tags.push(["p", note.pubkey]);
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
decryptDm: async (note: RawEvent): Promise<string | undefined> => {
|
|
if (pubKey) {
|
|
if (note.pubkey !== pubKey && !note.tags.some(a => a[1] === pubKey)) {
|
|
return "<CANT DECRYPT>";
|
|
}
|
|
try {
|
|
const otherPubKey = note.pubkey === pubKey ? unwrap(note.tags.filter(a => a[0] === "p")[0][1]) : note.pubkey;
|
|
if (hasNip07 && !privKey) {
|
|
return await barrierNip07(() => window.nostr.nip04.decrypt(otherPubKey, note.content));
|
|
} else if (privKey) {
|
|
return await EventExt.decryptDm(note.content, privKey, otherPubKey);
|
|
}
|
|
} catch (e) {
|
|
console.error("Decryption failed", e);
|
|
return "<DECRYPTION FAILED>";
|
|
}
|
|
}
|
|
},
|
|
sendDm: async (content: string, to: HexKey) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, EventKind.DirectMessage);
|
|
ev.content = content;
|
|
ev.tags.push(["p", to]);
|
|
|
|
try {
|
|
if (hasNip07 && !privKey) {
|
|
const cx: string = await barrierNip07(() => window.nostr.nip04.encrypt(to, content));
|
|
ev.content = cx;
|
|
return await signEvent(ev);
|
|
} else if (privKey) {
|
|
ev.content = await EventExt.encryptData(content, to, privKey);
|
|
return await signEvent(ev);
|
|
}
|
|
} catch (e) {
|
|
console.error("Encryption failed", e);
|
|
}
|
|
}
|
|
},
|
|
newKey: () => {
|
|
const privKey = secp.utils.bytesToHex(secp.utils.randomPrivateKey());
|
|
const pubKey = secp.utils.bytesToHex(secp.schnorr.getPublicKey(privKey));
|
|
return {
|
|
privateKey: privKey,
|
|
publicKey: pubKey,
|
|
};
|
|
},
|
|
generic: async (content: string, kind: EventKind, tags?: Array<Array<string>>) => {
|
|
if (pubKey) {
|
|
const ev = EventExt.forPubKey(pubKey, kind);
|
|
ev.content = content;
|
|
ev.tags = tags ?? [];
|
|
return await signEvent(ev);
|
|
}
|
|
},
|
|
};
|
|
|
|
return useMemo(() => ret, [pubKey, relays, follows]);
|
|
}
|
|
|
|
let isNip07Busy = false;
|
|
|
|
export const barrierNip07 = async <T>(then: () => Promise<T>): Promise<T> => {
|
|
while (isNip07Busy) {
|
|
await delay(10);
|
|
}
|
|
isNip07Busy = true;
|
|
try {
|
|
return await then();
|
|
} finally {
|
|
isNip07Busy = false;
|
|
}
|
|
};
|