Merge upstream develop

github-actions[bot] · github-actions[bot] · commit 9d225565e551 · 2026-07-13T11:19:33.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -31,7 +31,7 @@ tonic = { version = "0.14", default-features = false, features = ["codegen"] }
 tonic-prost = "0.14"
 
 # Crypto / hashing
-ed25519-dalek = "2.2.0"
+ed25519-dalek = "3.0.0"
 sha2 = "0.11"
 hmac-sha256 = "1.1.12"
 getrandom = "0.4"
diff --git a/apps/polycentric/app/(tabs)/_layout.tsx b/apps/polycentric/app/(tabs)/_layout.tsx
@@ -1,12 +1,41 @@
+import { usePolycentricContext } from '@/src/common/lib/polycentric-hooks';
 import { useTheme } from '@/src/common/theme';
 import { isIOS, isWeb } from '@/src/common/util/platform';
-import { Slot } from 'expo-router';
+import { Stack } from 'expo-router';
 import { NativeTabs } from 'expo-router/unstable-native-tabs';
 
 export default function TabsLayout() {
   const { theme } = useTheme();
+  const { currentIdentity, isLoading, isReady } = usePolycentricContext();
+
+  // Stay permissive until the identity store has settled — pruning routes
+  // during startup would break deep links that resolve after login state.
+  const accountGuard = isLoading || !isReady || !!currentIdentity;
+
   if (isWeb) {
-    return <Slot />;
+    // Web has no visible tab bar (the sidebar in Layout.tsx is the nav);
+    // a navigator is used instead of a plain <Slot/> so the account-only
+    // routes can be route-guarded. Guarded routes are removed from
+    // navigation while logged out; explore/search stay public.
+    return (
+      <Stack
+        screenOptions={{
+          headerShown: false,
+          animation: 'none',
+        }}
+      >
+        <Stack.Protected guard={accountGuard}>
+          <Stack.Screen name="feed" />
+          <Stack.Screen name="notifications" />
+          <Stack.Screen name="verifications" />
+          <Stack.Screen name="compose" />
+          <Stack.Screen name="profile" />
+          <Stack.Screen name="claims" />
+        </Stack.Protected>
+        <Stack.Screen name="explore" />
+        <Stack.Screen name="search" />
+      </Stack>
+    );
   }
 
   return (
diff --git a/apps/polycentric/app/_layout.tsx b/apps/polycentric/app/_layout.tsx
@@ -1,6 +1,9 @@
 import { Toaster } from '@/src/common/components/toast';
 import { LinkPreviewsProvider } from '@/src/common/link-previews';
-import { PolycentricProvider } from '@/src/common/lib/polycentric-hooks';
+import {
+  PolycentricProvider,
+  usePolycentricContext,
+} from '@/src/common/lib/polycentric-hooks';
 import { Atoms, ThemeProvider, useTheme } from '@/src/common/theme';
 import { isWeb } from '@/src/common/util/platform';
 import '@/src/common/util/react-native-screens-feature-flags';
@@ -26,6 +29,11 @@ export const unstable_settings = {
 
 function RootStack() {
   const { theme } = useTheme();
+  const { currentIdentity, isLoading, isReady } = usePolycentricContext();
+
+  // Stay permissive until the identity store has settled — pruning routes
+  // during startup would break deep links that resolve after login state.
+  const accountGuard = isLoading || !isReady || !!currentIdentity;
 
   const stack = (
     <>
@@ -40,25 +48,41 @@ function RootStack() {
             : { orientation: 'portrait_up' }),
         }}
       >
-        <Stack.Screen name="(tabs)" />
+        {/* Mobile requires an account for the tabs (feeds, notifications,
+            ...); deep-linked profile/post views stay public everywhere. On
+            web the tabs stay routable and get granular guards instead. */}
+        <Stack.Protected guard={isWeb || accountGuard}>
+          <Stack.Screen name="(tabs)" />
+        </Stack.Protected>
+
         <Stack.Screen name="(onboarding)" />
-        <Stack.Screen
-          name="feed"
-          options={{
-            presentation: 'transparentModal',
-            animation: isWeb ? 'fade' : 'default',
-            contentStyle: { backgroundColor: 'transparent' },
-          }}
-        />
-        <Stack.Screen name="settings" />
-        <Stack.Screen
-          name="[identityId]/edit"
-          options={{
-            presentation: 'transparentModal',
-            animation: 'none',
-            contentStyle: { backgroundColor: 'transparent' },
-          }}
-        />
+
+        {/* Account-only on every platform. Routes are auto-registered from
+            the filesystem; the explicit declarations here exist to place
+            them inside the guard. */}
+        <Stack.Protected guard={accountGuard}>
+          <Stack.Screen
+            name="feed"
+            options={{
+              presentation: 'transparentModal',
+              animation: isWeb ? 'fade' : 'default',
+              contentStyle: { backgroundColor: 'transparent' },
+            }}
+          />
+          <Stack.Screen name="settings" />
+          <Stack.Screen
+            name="[identityId]/edit"
+            options={{
+              presentation: 'transparentModal',
+              animation: 'none',
+              contentStyle: { backgroundColor: 'transparent' },
+            }}
+          />
+          <Stack.Screen name="identity/switch" />
+          <Stack.Screen name="verifications/index" />
+          <Stack.Screen name="verifications/claim" />
+        </Stack.Protected>
+
         <Stack.Screen
           name="image-viewer"
           options={{
diff --git a/apps/polycentric/src/features/profile/EditProfileScreen.tsx b/apps/polycentric/src/features/profile/EditProfileScreen.tsx
@@ -93,7 +93,7 @@ function EditProfileSheet({ identityKey }: { identityKey: string }) {
               <Text variant="small" color="neutral_500">
                 ALIAS
               </Text>
-              <InfoTooltip text="An alias like you@yourdomain.com that points to this profile. Your domain must be set up to link back here before it can be saved." />
+              <InfoTooltip text="An alias like you@yourdomain.com (or just yourdomain.com) that points to this profile. Your domain must be set up to link back here before it can be saved." />
             </View>
             <TextInput
               value={edit.aliasDraft}
diff --git a/apps/polycentric/src/features/profile/ProfileScreen.test.tsx b/apps/polycentric/src/features/profile/ProfileScreen.test.tsx
@@ -11,6 +11,8 @@ const ALIAS = 'test@domain.com';
 jest.mock('@polycentric/react-native', () => ({
   FetchMode: { Default: 'Default' },
   resolveAlias: jest.fn(),
+  isIdentityKey: (s: string): boolean =>
+    s.length > 0 && [...s].every((c) => '0123456789abcdefABCDEF'.includes(c)),
   normalizeAlias: (alias: string): string | null => {
     let s = alias.trim();
     if (s.startsWith('@')) s = s.slice(1);
diff --git a/apps/polycentric/src/features/profile/ProfileScreen.tsx b/apps/polycentric/src/features/profile/ProfileScreen.tsx
@@ -5,6 +5,7 @@ import { Atoms, useTheme } from '@/src/common/theme';
 import { useIdentityFeed } from '@/src/features/feed/hooks/useIdentityFeed';
 import {
   FetchMode,
+  isIdentityKey,
   normalizeAlias,
   resolveAlias,
 } from '@polycentric/react-native';
@@ -40,13 +41,12 @@ export default function ProfileScreen({
 }) {
   const { identityId } = useLocalSearchParams<{ identityId: string }>();
 
-  // An alias (user@domain) rather than a polycentric identity key —
-  // resolve it to a key first.
-  if (identityId?.includes('@')) {
-    return <AliasProfile alias={identityId} tab={tab} />;
+  if (!identityId || isIdentityKey(identityId)) {
+    return <IdentityProfile identityKey={identityId ?? null} tab={tab} />;
   }
 
-  return <IdentityProfile identityKey={identityId ?? null} tab={tab} />;
+  // An alias (user@domain, or a bare domain) — resolve it to a key first.
+  return <AliasProfile alias={identityId} tab={tab} />;
 }
 
 /**
diff --git a/apps/polycentric/src/features/profile/search/useProfileSuggestions.test.ts b/apps/polycentric/src/features/profile/search/useProfileSuggestions.test.ts
@@ -180,6 +180,26 @@ describe('useProfileSuggestions', () => {
     ]);
   });
 
+  it('resolves a bare-domain query as a wildcard alias', async () => {
+    const stranger = 'ef'.repeat(32);
+    mockResolve.mockResolvedValue(stranger);
+
+    const { result } = renderSuggestions('Example.com');
+    await act(async () => {
+      jest.advanceTimersByTime(300);
+    });
+
+    expect(mockResolve).toHaveBeenCalledWith('example.com');
+    expect(result.current.suggestions).toEqual([
+      {
+        identity: stranger,
+        name: null,
+        alias: 'example.com',
+        source: 'alias',
+      },
+    ]);
+  });
+
   it('shows nothing for an alias that does not resolve', async () => {
     mockResolve.mockResolvedValue(null);
 
diff --git a/apps/polycentric/src/features/profile/search/useProfileSuggestions.ts b/apps/polycentric/src/features/profile/search/useProfileSuggestions.ts
@@ -40,7 +40,8 @@ function isHex(s: string): boolean {
  * Suggests identities for a partially-typed profile query:
  * - people the current user follows, matched on profile name, alias, or
  *   identity-id prefix (everyone followed when the query is empty),
- * - the identity behind a `user@domain` alias, resolved over the network,
+ * - the identity behind a `user@domain` or bare-domain alias, resolved over
+ *   the network,
  * - the query itself when it's a pasted identity id.
  *
  * TODO: matching runs client-side over the first FOLLOWING_LIMIT follow
@@ -63,7 +64,7 @@ export function useProfileSuggestions(
   const profiles = useProfiles(followedIdentities);
 
   const trimmed = query.trim();
-  const aliasQuery = trimmed.includes('@') ? normalizeAlias(trimmed) : null;
+  const aliasQuery = normalizeAlias(trimmed);
 
   // Debounced alias → identity resolution; the result remembers which alias
   // it answered so a stale response never surfaces for a newer query.
diff --git a/docs/content/setting-up-an-alias.md b/docs/content/setting-up-an-alias.md
@@ -43,7 +43,7 @@ Three requirements:
 - It must be reachable over **HTTPS**.
 
 You can list several names in the same file if you host aliases for more than
-one person.
+one person. You can also use the name "*" to specify the identity that can use the bare domain alias (i.e. simply @domain.com instead of @user@domain.com).
 
 ## 2. Set the alias on your profile
 
diff --git a/packages/js-core/src/http/alias-resolver.test.ts b/packages/js-core/src/http/alias-resolver.test.ts
@@ -28,10 +28,21 @@ describe('normalizeAlias', () => {
     );
   });
 
+  it('accepts a bare domain (wildcard alias)', () => {
+    expect(normalizeAlias('Domain.COM')).toBe('domain.com');
+    expect(normalizeAlias('@domain.com')).toBe('domain.com');
+    expect(normalizeAlias('  domain.com  ')).toBe('domain.com');
+    expect(normalizeAlias('sub.domain.com')).toBe('sub.domain.com');
+  });
+
   it.each([
     ['empty', ''],
-    ['no @', 'nodomain'],
-    ['empty local part', '@domain.com'],
+    ['lone @', '@'],
+    ['single-label bare domain', 'nodomain'],
+    ['empty label in bare domain', 'domain..com'],
+    ['trailing dot in bare domain', 'domain.com.'],
+    ['bare domain with path', 'domain.com/path'],
+    ['literal wildcard local part', '*@domain.com'],
     ['multiple @', 'a@@b.com'],
     ['single-label domain', 'user@localhost'],
     ['underscore in domain label', 'user@dom_ain.com'],
@@ -97,6 +108,17 @@ describe('resolveAlias', () => {
     );
   });
 
+  it('resolves a bare domain via the wildcard entry', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ names: { '*': HEX_IDENTITY } }));
+
+    await expect(resolveAlias('example.com')).resolves.toBe(HEX_IDENTITY);
+
+    const [url] = fetchMock.mock.calls[0];
+    expect(url).toBe(
+      'https://example.com/.well-known/polycentric.json?alias=*',
+    );
+  });
+
   it('returns null on a non-2xx response', async () => {
     fetchMock.mockResolvedValue(jsonResponse({}, false));
     await expect(resolveAlias('test@example.com')).resolves.toBeNull();
diff --git a/packages/js-core/src/http/alias-resolver.ts b/packages/js-core/src/http/alias-resolver.ts
@@ -12,7 +12,7 @@ const HEX_CHARS = new Set('0123456789abcdefABCDEF');
 /**
  * Whether `s` is a polycentric identity string.
  */
-function isIdentityKey(s: string): boolean {
+export function isIdentityKey(s: string): boolean {
   return s.length > 0 && Array.from(s).every((c) => HEX_CHARS.has(c));
 }
 
@@ -61,18 +61,28 @@ function parseAlias(
     acct = acct.slice(1);
   }
 
-  // Exactly one '@', with a non-empty local part before it.
-  const at = acct.indexOf('@');
-  if (at <= 0 || acct.indexOf('@', at + 1) !== -1) {
-    return null;
-  }
-  // Lowercase the local part so the query, the names-map lookup, and alias
-  // comparison are all case-insensitive on a single canonical form.
-  const local = acct.slice(0, at).toLowerCase();
-  const domain = acct.slice(at + 1);
-
-  // Local part: every character must be in the conservative allow-list.
-  if (!Array.from(local).every((c) => LOCAL_CHARS.has(c))) {
+  let local: string;
+  let domain: string;
+  const parts = acct.split('@');
+  if (parts.length === 1) {
+    // A bare domain (`domain.com`) points at the domain's wildcard entry:
+    // the identity listed under `*` in its polycentric.json.
+    local = '*';
+    domain = parts[0];
+  } else if (parts.length === 2) {
+    // Lowercase the local part so the query, the names-map lookup, and alias
+    // comparison are all case-insensitive on a single canonical form.
+    local = parts[0].toLowerCase();
+    domain = parts[1];
+
+    // Local part: non-empty, every character in the conservative allow-list.
+    if (
+      local.length === 0 ||
+      !Array.from(local).every((c) => LOCAL_CHARS.has(c))
+    ) {
+      return null;
+    }
+  } else {
     return null;
   }
 
diff --git a/packages/js-core/src/index.ts b/packages/js-core/src/index.ts
@@ -56,5 +56,9 @@ export {
   HydrationStatus,
 } from './client-internal/event-service';
 
-export { resolveAlias, normalizeAlias } from './http/alias-resolver';
+export {
+  resolveAlias,
+  normalizeAlias,
+  isIdentityKey,
+} from './http/alias-resolver';
 export { CryptoManager } from './crypto/crypto-manager';
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/services/common/object-store/Cargo.toml b/services/common/object-store/Cargo.toml
