Merge branch 'mh/hints' into 'develop'

Introduce Hints

See merge request polycentric/polycentric!515

Author: markharding

apps/polycentric/src/features/feed/hooks/useExploreFeed.ts

@@ -43,6 +43,7 @@ export function useExploreFeed(options?: {
       undefined,
       undefined,
       undefined,
+      undefined,
     );
     subscriptionRef.current = observable.subscribe({
       next: (result) => {

apps/polycentric/src/features/feed/hooks/useFollowingFeed.ts

@@ -48,6 +48,7 @@ export function useFollowingFeed(options?: {
       undefined,
       undefined,
       undefined,
+      undefined,
     );
     subscriptionRef.current = observable.subscribe({
       next: (result) => {

apps/polycentric/src/features/feed/hooks/useIdentityFeed.ts

@@ -47,6 +47,7 @@ export function useIdentityFeed(
       undefined,
       undefined,
       undefined,
+      undefined,
     );
     subscriptionRef.current = observable.subscribe({
       next: (result) => {

apps/polycentric/src/features/post/hooks/usePostById.ts

@@ -1,79 +1,103 @@
-import { useEffect, useState } from 'react';
-import { COLLECTION, v2 } from '@polycentric/react-native';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { COLLECTION, QueryStatus, v2 } from '@polycentric/react-native';
 import {
-  bytesToHex,
   decodeV2PostBundle,
-  hexToBytes,
   usePolycentricContext,
   type PostData,
 } from '@/src/common/lib/polycentric-hooks';
 import { getKeyFingerprint } from '@/src/common/lib/polycentric-hooks/helpers';
 
+type Sub = { unsubscribe: () => void };
+
 /**
  * Load a single post by its (identity, sequence) route params.
  *
- * Uses `listEvents` with `sequenceGt = seq - 1` / `sequenceLt = seq + 1` to
- * pin the query to exactly one sequence number server-side. No local cache —
- * the detail screen re-queries when it mounts.
+ * Subscribes to `core.getEvent`, which checks the local store first
+ * and falls back to a `ListEvents` query with `sequenceGt = seq - 1`
+ * / `sequenceLt = seq + 1` to pin the network query to exactly one
+ * sequence. `keyFingerprint` is used only to verify the returned
+ * bundle matches the expected signer; the rust side picks the first
+ * local-store hit at that sequence.
  */
 export function usePostById(
   identityId: string | undefined,
   keyFingerprint: string | undefined,
-  sequence: BigInt | undefined,
+  sequence: bigint | undefined,
 ): { post: PostData | null; isLoading: boolean; error: Error | null } {
   const { client } = usePolycentricContext();
   const [post, setPost] = useState<PostData | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
+  // Hold the live subscription so we can cancel on unmount / param change.
+  const subscriptionRef = useRef<Sub | null>(null);
+  const cleanup = useCallback(() => {
+    subscriptionRef.current?.unsubscribe();
+    subscriptionRef.current = null;
+  }, []);
+
   useEffect(() => {
-    if (!keyFingerprint || !identityId || !sequence) {
+    cleanup();
+    if (!identityId || sequence == null || !keyFingerprint) {
       setPost(null);
+      setIsLoading(false);
+      setError(null);
       return;
     }
 
-    let cancelled = false;
-    setIsLoading(true);
+    setPost(null);
     setError(null);
+    setIsLoading(true);
 
-    (async () => {
-      try {
-        const bundles = await client.listEvents({
-          identity: identityId,
-          collection: COLLECTION.FEED,
-          sequenceGt: Number(sequence) - 1,
-          sequenceLt: Number(sequence) + 1,
-        });
-        if (cancelled) return;
+    const observable = client.core.getEvent(
+      identityId,
+      COLLECTION.FEED,
+      sequence,
+      undefined,
+    );
 
-        const match = bundles.find((b) => {
-          if (!b.signedEvent) return false;
+    subscriptionRef.current = observable.subscribe({
+      next: (result) => {
+        if (result.data && result.data.byteLength > 0) {
           try {
-            const ev = v2.Event.fromBinary(b.signedEvent.eventBytes);
-            if (!ev.vectorClock) return false;
-            return (
-              getKeyFingerprint(ev.key?.signedBy) === keyFingerprint &&
-              ev.key?.sequence === sequence
+            const bundle = v2.EventBundle.fromBinary(
+              new Uint8Array(result.data),
             );
+            // Verify the signer fingerprint matches the URL so a
+            // sequence collision across signers doesn't render the
+            // wrong post.
+            if (bundle.signedEvent) {
+              const ev = v2.Event.fromBinary(bundle.signedEvent.eventBytes);
+              if (
+                getKeyFingerprint(ev.key?.signedBy) === keyFingerprint &&
+                ev.key?.sequence === sequence
+              ) {
+                setPost(decodeV2PostBundle(bundle));
+              } else if (result.status === QueryStatus.Success) {
+                setPost(null);
+              }
+            } else if (result.status === QueryStatus.Success) {
+              setPost(null);
+            }
           } catch {
-            return false;
+            // Ignore malformed bundle, wait for next emission or completion.
           }
-        });
-
-        setPost(match ? decodeV2PostBundle(match) : null);
-      } catch (e) {
-        if (!cancelled) {
-          setError(e instanceof Error ? e : new Error(String(e)));
+        } else if (result.status === QueryStatus.Success) {
+          setPost(null);
         }
-      } finally {
-        if (!cancelled) setIsLoading(false);
-      }
-    })();
+        setIsLoading(result.status === QueryStatus.Loading);
+      },
+      error: (message: string) => {
+        setError(new Error(message));
+        setIsLoading(false);
+      },
+      complete: () => {
+        setIsLoading(false);
+      },
+    });
 
-    return () => {
-      cancelled = true;
-    };
-  }, [client, identityId, keyFingerprint, sequence]);
+    return cleanup;
+  }, [client, identityId, keyFingerprint, sequence, cleanup]);
 
   return { post, isLoading, error };
 }

apps/polycentric/src/features/post/hooks/useThread.ts

@@ -1,12 +1,19 @@
-import { useEffect, useState } from 'react';
-import { COLLECTION, v2 } from '@polycentric/react-native';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  COLLECTION,
+  QueryStatus,
+  v2,
+  type EventKey,
+} from '@polycentric/react-native';
 import {
   decodeV2PostBundle,
   useLocalPostInjection,
   usePolycentricContext,
   type PostData,
 } from '@/src/common/lib/polycentric-hooks';
 
+type Sub = { unsubscribe: () => void };
+
 /**
  * Load the thread for a given post via the server's `GetPostThread` RPC.
  * The server returns a flat ordered list — ancestors (root → direct parent),
@@ -24,48 +31,76 @@ export function useThread(
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
+  // Hold the live subscription so we can cancel on unmount / refresh /
+  // post change. The rust core fans out to every configured server
+  // and pushes one `next` per server, then a single `complete`.
+  const subscriptionRef = useRef<Sub | null>(null);
+
+  const cleanup = useCallback(() => {
+    subscriptionRef.current?.unsubscribe();
+    subscriptionRef.current = null;
+  }, []);
+
   useEffect(() => {
+    cleanup();
     if (!post) {
       setThread([]);
+      setIsLoading(false);
+      setError(null);
       return;
     }
 
-    let cancelled = false;
-    setIsLoading(true);
+    setThread([]);
     setError(null);
+    setIsLoading(true);
 
-    (async () => {
-      try {
-        const response = await client.getPostThread({
-          eventKey: v2.EventKey.create({
-            collection: COLLECTION.FEED,
-            identity: post.identity,
-            signedBy: post.signedBy,
-            sequence: BigInt(post.sequence),
-          }),
-          limit: options?.limit ?? null,
-        });
-        if (cancelled) return;
+    // `post.signedBy.key` is a Uint8Array view into the wire-decoded
+    // message buffer (protobuf-ts uses subarray). `.buffer` would be
+    // the whole message buffer, not just the key bytes — copy through
+    // `.slice()` so the FFI receives exactly the public-key bytes.
+    const keyBytes = post.signedBy.key.slice().buffer as ArrayBuffer;
+    const eventKey: EventKey = {
+      collection: COLLECTION.FEED,
+      identity: post.identity,
+      signedBy: {
+        keyType: post.signedBy.keyType,
+        key: keyBytes,
+      },
+      sequence: BigInt(post.sequence),
+    };
 
-        const decoded: PostData[] = [];
-        for (const bundle of response?.thread ?? []) {
-          const d = decodeV2PostBundle(bundle);
-          if (d) decoded.push(d);
-        }
-        setThread(decoded);
-      } catch (e) {
-        if (!cancelled) {
-          setError(e instanceof Error ? e : new Error(String(e)));
+    const observable = client.core.getPostThread(
+      eventKey,
+      options?.limit ?? 0,
+      undefined,
+    );
+
+    subscriptionRef.current = observable.subscribe({
+      next: (result) => {
+        if (result.data) {
+          const response = v2.GetPostThreadResponse.fromBinary(
+            new Uint8Array(result.data),
+          );
+          const decoded: PostData[] = [];
+          for (const bundle of response.thread) {
+            const d = decodeV2PostBundle(bundle);
+            if (d) decoded.push(d);
+          }
+          setThread(decoded);
         }
-      } finally {
-        if (!cancelled) setIsLoading(false);
-      }
-    })();
+        setIsLoading(result.status === QueryStatus.Loading);
+      },
+      error: (message: string) => {
+        setError(new Error(message));
+        setIsLoading(false);
+      },
+      complete: () => {
+        setIsLoading(false);
+      },
+    });
 
-    return () => {
-      cancelled = true;
-    };
-  }, [client, post, options?.limit]);
+    return cleanup;
+  }, [client, post, options?.limit, cleanup]);
 
   useLocalPostInjection({
     enabled: !!post,

apps/polycentric/src/features/profile/EditProfileScreen.tsx

@@ -13,6 +13,7 @@ import {
 } from '@/src/common/lib/sheet';
 import { Atoms } from '@/src/common/theme';
 import { useProfile } from '@/src/features/profile/hooks/useProfile';
+import { FetchMode } from '@polycentric/react-native';
 import { router, useLocalSearchParams } from 'expo-router';
 import { useCallback } from 'react';
 import { View } from 'react-native';
@@ -25,7 +26,7 @@ function EditProfileSheet({
   dismissSheet: DismissSheet;
 }) {
   const fallbackUsername = useUsername(identityKey);
-  const profile = useProfile(identityKey);
+  const profile = useProfile(identityKey, { fetchMode: FetchMode.Default });
   const username = profile.name ?? fallbackUsername;
   const edit = useProfileEdit(username, profile);
 

apps/polycentric/src/features/profile/ProfileHeader.tsx

@@ -14,6 +14,7 @@ import {
 import { Atoms } from '@/src/common/theme';
 import { FeedChip } from '@/src/features/post/FeedChip';
 import { useProfile } from '@/src/features/profile/hooks/useProfile';
+import { FetchMode } from '@polycentric/react-native';
 import { router } from 'expo-router';
 import { memo, useCallback } from 'react';
 import { View } from 'react-native';
@@ -32,7 +33,7 @@ function ProfileHeaderInner({ bannerColors, onBack }: ProfileHeaderProps) {
     useProfileContext();
 
   const fallbackUsername = useUsername(identityKey);
-  const profile = useProfile(identityKey);
+  const profile = useProfile(identityKey, { fetchMode: FetchMode.Default });
   const username = profile.name ?? fallbackUsername;
 
   const short = identityKey ? shortenIdentityId(identityKey) : '...';

apps/polycentric/src/features/profile/hooks/useProfile.ts

@@ -1,5 +1,5 @@
 import { useCallback, useEffect } from 'react';
-import { v2 } from '@polycentric/react-native';
+import { FetchMode, v2 } from '@polycentric/react-native';
 import { usePolycentric } from '@/src/common/lib/polycentric-hooks';
 import useProfiles, { emptyProfile } from './useProfiles';
 
@@ -13,22 +13,31 @@ export interface ProfileHookResult {
   refresh: () => void;
 }
 
+export interface UseProfileOptions {
+  /**
+   * Defaults to  `OfflineOnly` (will not fetch unless its found in caches)
+   */
+  fetchMode?: FetchMode;
+}
+
 export function useProfile(
   identityKey: string | null | undefined,
+  options?: UseProfileOptions,
 ): ProfileHookResult {
   const client = usePolycentric();
+  const fetchMode = options?.fetchMode ?? FetchMode.OfflineOnly;
   const profile = useProfiles((s) =>
     identityKey ? s.profiles.get(identityKey) : undefined,
   );
 
   useEffect(() => {
     if (!identityKey) return;
-    void useProfiles.getState().fetchProfile(client, identityKey);
-  }, [client, identityKey]);
+    useProfiles.getState().fetchProfile(client, identityKey, fetchMode);
+  }, [client, identityKey, fetchMode]);
 
   const refresh = useCallback(() => {
     if (!identityKey) return;
-    void useProfiles.getState().fetchProfile(client, identityKey, true);
+    useProfiles.getState().fetchProfile(client, identityKey, FetchMode.Default);
   }, [client, identityKey]);
 
   const data = profile ?? emptyProfile(identityKey ?? '');