feat: support user handles

packages/api-main/drizzle/db.ts

@@ -6,11 +6,13 @@ import pg from 'pg';
 
 dotenv.config();
 
+export type DbClient = ReturnType<typeof drizzle>;
+
 const { Pool } = pg;
 
-let db: ReturnType<typeof drizzle>;
+let db: DbClient;
 
-export function getDatabase() {
+export function getDatabase(): DbClient {
   if (!db) {
     const client = new Pool({
       connectionString: process.env.PG_URI!,

packages/api-main/drizzle/schema.ts

@@ -3,6 +3,35 @@ import { bigint, boolean, index, integer, pgEnum, pgTable, primaryKey, serial, t
 
 const MEMO_LENGTH = 512;
 
+export const HandleTable = pgTable(
+  'handle',
+  {
+    name: varchar({ length: 32 }).primaryKey(),
+    address: varchar({ length: 44 }).notNull(),
+    display: varchar({ length: 128 }),
+    hash: varchar({ length: 64 }).notNull(),
+    timestamp: timestamp({ withTimezone: true }).notNull(),
+  },
+  t => [
+    index('handle_address_idx').on(t.address),
+    index('handle_display_idx').on(t.display),
+  ],
+);
+
+export const HandleTransferTable = pgTable(
+  'handle_transfer',
+  {
+    hash: varchar({ length: 64 }).notNull(),
+    name: varchar({ length: 32 }).notNull(),
+    from_address: varchar({ length: 44 }).notNull(),
+    to_address: varchar({ length: 44 }).notNull(),
+    timestamp: timestamp({ withTimezone: true }).notNull(),
+  },
+  t => [
+    index('handle_transfer_to_idx').on(t.name, t.to_address),
+  ],
+);
+
 export const FeedTable = pgTable(
   'feed',
   {
@@ -129,7 +158,14 @@ export const ModeratorTable = pgTable('moderators', {
   deleted_at: timestamp({ withTimezone: true }),
 });
 
-export const notificationTypeEnum = pgEnum('notification_type', ['like', 'dislike', 'flag', 'follow', 'reply']);
+export const notificationTypeEnum = pgEnum('notification_type', [
+  'like',
+  'dislike',
+  'flag',
+  'follow',
+  'reply',
+  'registerHandle',
+]);
 
 export const NotificationTable = pgTable(
   'notifications',
@@ -166,4 +202,6 @@ export const tables = [
   'state',
   'authrequests',
   'ratelimits',
+  'handle',
+  'handle_transfer',
 ];

packages/api-main/src/gets/feed.ts

@@ -1,13 +1,18 @@
 import type { Gets } from '@atomone/dither-api-types';
 
-import { and, count, desc, gte, isNull, sql } from 'drizzle-orm';
+import { and, count, desc, eq, getTableColumns, gte, isNull, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FeedTable } from '../../drizzle/schema';
+import { FeedTable, HandleTable } from '../../drizzle/schema';
 
 const statement = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    handle: HandleTable.name,
+    display: HandleTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
   .limit(sql.placeholder('limit'))
   .offset(sql.placeholder('offset'))
   .where(

packages/api-main/src/gets/followers.ts

@@ -3,11 +3,17 @@ import type { Gets } from '@atomone/dither-api-types';
 import { and, desc, eq, isNull, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FollowsTable } from '../../drizzle/schema';
+import { FollowsTable, HandleTable } from '../../drizzle/schema';
 
 const statementGetFollowers = getDatabase()
-  .select({ address: FollowsTable.follower, hash: FollowsTable.hash })
+  .select({
+    address: FollowsTable.follower,
+    handle: HandleTable.name,
+    display: HandleTable.display,
+    hash: FollowsTable.hash,
+  })
   .from(FollowsTable)
+  .leftJoin(HandleTable, eq(HandleTable.address, FollowsTable.follower))
   .where(and(eq(FollowsTable.following, sql.placeholder('following')), isNull(FollowsTable.removed_at)))
   .limit(sql.placeholder('limit'))
   .offset(sql.placeholder('offset'))

packages/api-main/src/gets/following.ts

@@ -3,11 +3,17 @@ import type { Gets } from '@atomone/dither-api-types';
 import { and, desc, eq, isNull, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FollowsTable } from '../../drizzle/schema';
+import { FollowsTable, HandleTable } from '../../drizzle/schema';
 
 const statementGetFollowing = getDatabase()
-  .select({ address: FollowsTable.following, hash: FollowsTable.hash })
+  .select({
+    address: FollowsTable.following,
+    handle: HandleTable.name,
+    display: HandleTable.display,
+    hash: FollowsTable.hash,
+  })
   .from(FollowsTable)
+  .leftJoin(HandleTable, eq(HandleTable.address, FollowsTable.follower))
   .where(and(eq(FollowsTable.follower, sql.placeholder('follower')), isNull(FollowsTable.removed_at)))
   .limit(sql.placeholder('limit'))
   .offset(sql.placeholder('offset'))

packages/api-main/src/gets/handle.ts

@@ -0,0 +1,42 @@
+import type { Gets } from '@atomone/dither-api-types';
+
+import { eq, or, sql } from 'drizzle-orm';
+
+import { getDatabase } from '../../drizzle/db';
+import { HandleTable } from '../../drizzle/schema';
+
+const statement = getDatabase()
+  .select({
+    name: HandleTable.name,
+    address: HandleTable.address,
+    display: HandleTable.display,
+  })
+  .from(HandleTable)
+  .where(
+    or(
+      eq(HandleTable.name, sql.placeholder('name')),
+      eq(HandleTable.address, sql.placeholder('address')),
+    ),
+  )
+  .orderBy(HandleTable.name)
+  .limit(1)
+  .prepare('stmnt_get_handle');
+
+export async function Handle(query: Gets.HandleQuery) {
+  const { address, name } = query;
+  if (!address && !name) {
+    return { status: 400, error: 'handle name or address is required' };
+  }
+
+  try {
+    const [handle] = await statement.execute({ address, name });
+    if (!handle) {
+      return { status: 404, rows: [] };
+    }
+
+    return { status: 200, rows: [handle] };
+  } catch (error) {
+    console.error(error);
+    return { error: 'failed to read data from database' };
+  }
+}

packages/api-main/src/gets/index.ts

@@ -4,6 +4,7 @@ export * from './feed';
 export * from './flags';
 export * from './followers';
 export * from './following';
+export * from './handle';
 export * from './health';
 export * from './isFollowing';
 export * from './lastBlock';

packages/api-main/src/gets/post.ts

@@ -1,19 +1,28 @@
 import type { Gets } from '@atomone/dither-api-types';
 
-import { and, eq, isNull, sql } from 'drizzle-orm';
+import { and, eq, getTableColumns, isNull, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FeedTable } from '../../drizzle/schema';
+import { FeedTable, HandleTable } from '../../drizzle/schema';
 
 const statementGetPost = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    handle: HandleTable.name,
+    display: HandleTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
   .where(and(isNull(FeedTable.removed_at), eq(FeedTable.hash, sql.placeholder('hash'))))
   .prepare('stmnt_get_post');
 
 const statementGetReply = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    handle: HandleTable.name,
+  })
   .from(FeedTable)
+  .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
   .where(and(isNull(FeedTable.removed_at), eq(FeedTable.hash, sql.placeholder('hash')), eq(FeedTable.post_hash, sql.placeholder('post_hash'))))
   .prepare('stmnt_get_reply');
 

packages/api-main/src/gets/posts.ts

@@ -1,13 +1,18 @@
 import type { Gets } from '@atomone/dither-api-types';
 
-import { and, desc, eq, gte, inArray, isNull, sql } from 'drizzle-orm';
+import { and, desc, eq, getTableColumns, gte, inArray, isNull, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FeedTable, FollowsTable } from '../../drizzle/schema';
+import { FeedTable, FollowsTable, HandleTable } from '../../drizzle/schema';
 
 const statement = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    handle: HandleTable.name,
+    display: HandleTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
   .where(
     and(
       eq(FeedTable.author, sql.placeholder('author')),

packages/api-main/src/gets/search.ts

@@ -1,9 +1,9 @@
 import type { Gets } from '@atomone/dither-api-types';
 
-import { and, desc, gte, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
+import { and, desc, eq, getTableColumns, gte, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
 
 import { getDatabase } from '../../drizzle/db';
-import { FeedTable } from '../../drizzle/schema';
+import { FeedTable, HandleTable } from '../../drizzle/schema';
 
 export async function Search(query: Gets.SearchQuery) {
   try {
@@ -22,12 +22,26 @@ export async function Search(query: Gets.SearchQuery) {
     const matchedAuthors = await getDatabase()
       .selectDistinct({ author: FeedTable.author })
       .from(FeedTable)
-      .where(and(ilike(FeedTable.author, `%${query.text}%`), isNull(FeedTable.removed_at)));
+      .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
+      .where(
+        and(
+          or(
+            eq(FeedTable.author, query.text.toLowerCase()), // Exact address
+            ilike(HandleTable.name, `%${query.text}%`), // Registered handle (partial match)
+          ),
+          isNull(FeedTable.removed_at),
+        ),
+      );
     const matchedAuthorAddresses = matchedAuthors.map(a => a.author);
 
     const matchedPosts = await getDatabase()
-      .select()
+      .select({
+        ...getTableColumns(FeedTable),
+        handle: HandleTable.name,
+        display: HandleTable.display,
+      })
       .from(FeedTable)
+      .leftJoin(HandleTable, eq(FeedTable.author, HandleTable.address))
       .where(
         and(
           or(
@@ -40,8 +54,8 @@ export async function Search(query: Gets.SearchQuery) {
       )
       .limit(100)
       .offset(0)
-      .orderBy(desc(FeedTable.timestamp))
-      .execute();
+      .orderBy(desc(FeedTable.timestamp));
+
     return { status: 200, rows: [...matchedPosts], users: matchedAuthorAddresses };
   } catch (error) {
     console.error(error);

packages/api-main/src/posts/acceptHandle.ts

@@ -0,0 +1,36 @@
+import type { Posts } from '@atomone/dither-api-types';
+
+import type { DbClient } from '../../drizzle/db';
+
+import { and, eq } from 'drizzle-orm';
+
+import { getDatabase } from '../../drizzle/db';
+import { HandleTable, HandleTransferTable } from '../../drizzle/schema';
+import { lower } from '../utility';
+
+export async function AcceptHandle(body: Posts.AcceptHandleBody) {
+  const db = getDatabase();
+  try {
+    if (!await doesTransferToAddressExists(db, body.handle, body.to_address)) {
+      return { status: 400, error: 'handle not found or not transferred to address' };
+    }
+
+    await db
+      .update(HandleTable)
+      .set({ address: body.to_address.toLowerCase() })
+      .where(eq(lower(HandleTable.name), body.handle.toLowerCase()));
+
+    return { status: 200 };
+  } catch (err) {
+    console.error(err);
+    return { status: 400, error: 'failed to transfer handle' };
+  }
+}
+
+async function doesTransferToAddressExists(db: DbClient, handle: string, address: string): Promise<boolean> {
+  const count = await db.$count(HandleTransferTable, and(
+    eq(lower(HandleTransferTable.name), handle.toLowerCase()),
+    eq(HandleTransferTable.to_address, address.toLowerCase()),
+  ));
+  return count !== 0;
+}

packages/api-main/src/posts/displayHandle.ts

@@ -0,0 +1,44 @@
+import type { Posts } from '@atomone/dither-api-types';
+
+import { count, eq, sql } from 'drizzle-orm';
+
+import { getDatabase } from '../../drizzle/db';
+import { HandleTable } from '../../drizzle/schema';
+import { lower } from '../utility';
+import { MAX_DISPLAY_LENGTH } from './registerHandle';
+
+const handleAddressExistsStmt = getDatabase()
+  .select({ count: count() })
+  .from(HandleTable)
+  .where(eq(lower(HandleTable.address), sql.placeholder('address')))
+  .prepare('stmt_handle_address_exists');
+
+export async function DisplayHandle(body: Posts.DisplayHandleBody) {
+  const display = (body.display || '').trim();
+  if (display.length > MAX_DISPLAY_LENGTH) {
+    return { status: 400, error: `maximum display length is ${MAX_DISPLAY_LENGTH} characters long` };
+  }
+
+  const db = getDatabase();
+  try {
+    const address = body.from.toLowerCase();
+    if (!await hasHandle(address)) {
+      return { status: 400, error: 'account requires a handle to set a display text' };
+    }
+
+    await db
+      .update(HandleTable)
+      .set({ display })
+      .where(eq(HandleTable.address, address));
+
+    return { status: 200 };
+  } catch (err) {
+    console.error(err);
+    return { status: 400, error: 'failed to update display handle' };
+  }
+}
+
+async function hasHandle(address: string): Promise<boolean> {
+  const [result] = await handleAddressExistsStmt.execute({ address });
+  return (result?.count ?? 0) !== 0;
+}

packages/api-main/src/posts/index.ts

@@ -1,13 +1,17 @@
+export * from './acceptHandle';
 export * from './auth';
 export * from './authCreate';
 export * from './dislike';
+export * from './displayHandle';
 export * from './flag';
 export * from './follow';
 export * from './like';
 export * from './logout';
 export * from './mod';
 export * from './post';
 export * from './postRemove';
+export * from './registerHandle';
 export * from './reply';
+export * from './transferHandle';
 export * from './unfollow';
 export * from './updateState';