snort/src/Feed/LoginFeed.ts

import { useEffect, useMemo } from "react";
import { useDispatch, useSelector } from "react-redux";

import { makeNotification } from "Notifications";
import { TaggedRawEvent, HexKey, Lists } from "Nostr";
import EventKind from "Nostr/EventKind";
import Event from "Nostr/Event";
import { Subscriptions } from "Nostr/Subscriptions";
import {
  addDirectMessage,
  setFollows,
  setRelays,
  setMuted,
  setBlocked,
  sendNotification,
  setLatestNotifications,
} from "State/Login";
import { RootState } from "State/Store";
import { mapEventToProfile, MetadataCache } from "State/Users";
import { useDb } from "State/Users/Db";
import useSubscription from "Feed/Subscription";
import { barierNip07 } from "Feed/EventPublisher";
import { getMutedKeys, getNewest } from "Feed/MuteList";
import useModeration from "Hooks/useModeration";

/**
 * Managed loading data for the current logged in user
 */
export default function useLoginFeed() {
  const dispatch = useDispatch();
  const {
    publicKey: pubKey,
    privateKey: privKey,
    latestMuted,
    readNotifications,
  } = useSelector((s: RootState) => s.login);
  const { isMuted } = useModeration();
  const db = useDb();

  const subMetadata = useMemo(() => {
    if (!pubKey) return null;

    let sub = new Subscriptions();
    sub.Id = `login:meta`;
    sub.Authors = new Set([pubKey]);
    sub.Kinds = new Set([EventKind.ContactList, EventKind.SetMetadata]);
    sub.Limit = 2;

    return sub;
  }, [pubKey]);

  const subNotification = useMemo(() => {
    if (!pubKey) return null;

    let sub = new Subscriptions();
    sub.Id = "login:notifications";
    // todo: add zaps
    sub.Kinds = new Set([EventKind.TextNote]);
    sub.PTags = new Set([pubKey]);
    sub.Limit = 1;
    return sub;
  }, [pubKey]);

  const subMuted = useMemo(() => {
    if (!pubKey) return null;

    let sub = new Subscriptions();
    sub.Id = "login:muted";
    sub.Kinds = new Set([EventKind.Lists]);
    sub.Authors = new Set([pubKey]);
    sub.DTags = new Set([Lists.Muted]);
    sub.Limit = 1;

    return sub;
  }, [pubKey]);

  const subDms = useMemo(() => {
    if (!pubKey) return null;

    let dms = new Subscriptions();
    dms.Id = "login:dms";
    dms.Kinds = new Set([EventKind.DirectMessage]);
    dms.PTags = new Set([pubKey]);

    let dmsFromME = new Subscriptions();
    dmsFromME.Authors = new Set([pubKey]);
    dmsFromME.Kinds = new Set([EventKind.DirectMessage]);
    dms.AddSubscription(dmsFromME);

    return dms;
  }, [pubKey]);

  const metadataFeed = useSubscription(subMetadata, {
    leaveOpen: true,
    cache: true,
  });
  const notificationFeed = useSubscription(subNotification, {
    leaveOpen: true,
    cache: true,
  });
  const dmsFeed = useSubscription(subDms, { leaveOpen: true, cache: true });
  const mutedFeed = useSubscription(subMuted, { leaveOpen: true, cache: true });

  useEffect(() => {
    let contactList = metadataFeed.store.notes.filter(
      (a) => a.kind === EventKind.ContactList
    );
    let metadata = metadataFeed.store.notes.filter(
      (a) => a.kind === EventKind.SetMetadata
    );
    let profiles = metadata
      .map((a) => mapEventToProfile(a))
      .filter((a) => a !== undefined)
      .map((a) => a!);

    for (let cl of contactList) {
      if (cl.content !== "" && cl.content !== "{}") {
        let relays = JSON.parse(cl.content);
        dispatch(setRelays({ relays, createdAt: cl.created_at }));
      }
      let pTags = cl.tags.filter((a) => a[0] === "p").map((a) => a[1]);
      dispatch(setFollows({ keys: pTags, createdAt: cl.created_at }));
    }

    (async () => {
      let maxProfile = profiles.reduce(
        (acc, v) => {
          if (v.created > acc.created) {
            acc.profile = v;
            acc.created = v.created;
          }
          return acc;
        },
        { created: 0, profile: null as MetadataCache | null }
      );
      if (maxProfile.profile) {
        let existing = await db.find(maxProfile.profile.pubkey);
        if ((existing?.created ?? 0) < maxProfile.created) {
          await db.put(maxProfile.profile);
        }
      }
    })().catch(console.warn);
  }, [dispatch, metadataFeed.store, db]);

  useEffect(() => {
    const replies = notificationFeed.store.notes.filter(
      (a) =>
        a.kind === EventKind.TextNote &&
        !isMuted(a.pubkey) &&
        a.created_at > readNotifications
    );
    replies.forEach((nx) => {
      dispatch(setLatestNotifications(nx.created_at));
      makeNotification(db, nx).then((notification) => {
        if (notification) {
          // @ts-ignore
          dispatch(sendNotification(notification));
        }
      });
    });
  }, [dispatch, notificationFeed.store, db, readNotifications]);

  useEffect(() => {
    const muted = getMutedKeys(mutedFeed.store.notes);
    dispatch(setMuted(muted));

    const newest = getNewest(mutedFeed.store.notes);
    if (
      newest &&
      newest.content.length > 0 &&
      pubKey &&
      newest.created_at > latestMuted
    ) {
      decryptBlocked(newest, pubKey, privKey)
        .then((plaintext) => {
          try {
            const blocked = JSON.parse(plaintext);
            const keys = blocked
              .filter((p: any) => p && p.length === 2 && p[0] === "p")
              .map((p: any) => p[1]);
            dispatch(
              setBlocked({
                keys,
                createdAt: newest.created_at,
              })
            );
          } catch (error) {
            console.debug("Couldn't parse JSON");
          }
        })
        .catch((error) => console.warn(error));
    }
  }, [dispatch, mutedFeed.store]);

  useEffect(() => {
    let dms = dmsFeed.store.notes.filter(
      (a) => a.kind === EventKind.DirectMessage
    );
    dispatch(addDirectMessage(dms));
  }, [dispatch, dmsFeed.store]);
}

async function decryptBlocked(
  raw: TaggedRawEvent,
  pubKey: HexKey,
  privKey?: HexKey
) {
  const ev = new Event(raw);
  if (pubKey && privKey) {
    return await ev.DecryptData(raw.content, privKey, pubKey);
  } else {
    return await barierNip07(() =>
      window.nostr.nip04.decrypt(pubKey, raw.content)
    );
  }
}