feat: support user handles

.dockerignore

@@ -2,3 +2,5 @@
 **/node_modules
 **/dist
 **/dist/*
+.husky/
+.vscode/

Tiltfile

@@ -5,15 +5,15 @@ docker_compose('docker-compose.yml')
 docker_build('ditherchat/api-main', '.',
   dockerfile = './packages/api-main/Dockerfile',
   live_update = [
-    sync('./packages/api-main/src', '/app'),
+    sync('./packages/api-main/src', '/app/packages/api-main/src'),
     run('bun install', trigger='package.json'),
     restart_container(),
   ])
 
 docker_build('ditherchat/reader-main', '.',
   dockerfile = './packages/reader-main/Dockerfile',
   live_update = [
-    sync('./packages/reader-main/src', '/app'),
+    sync('./packages/reader-main/src', '/app/packages/reader-main/src'),
     run('bun install', trigger='package.json'),
     restart_container(),
   ])

docker-compose.yml

@@ -72,6 +72,8 @@ services:
       RECEIVER: atone1uq6zjslvsa29cy6uu75y8txnl52mw06j6fzlep
       API_ROOT: 'http://api-main:3000/v1'
       AUTH: dev
+      MIN_REGISTER_HANDLE_FEE: '0.000001'
+
       # Uncomment to enable fast sync
       # ECLESIA_GRAPHQL_ENDPOINT: "https://graphql-atomone-testnet-1.allinbits.services/v1/graphql"
       # ECLESIA_GRAPHQL_SECRET: ""

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

@@ -1,8 +1,36 @@
 import { sql } from 'drizzle-orm';
-import { bigint, boolean, index, integer, pgEnum, pgTable, primaryKey, serial, text, timestamp, varchar } from 'drizzle-orm/pg-core';
+import { bigint, boolean, index, integer, pgEnum, pgTable, primaryKey, serial, text, timestamp, unique, varchar } from 'drizzle-orm/pg-core';
 
 const MEMO_LENGTH = 512;
 
+export const AccountTable = pgTable(
+  'account',
+  {
+    address: varchar({ length: 44 }).primaryKey(),
+    handle: varchar({ length: 25 }),
+    display: varchar({ length: 128 }),
+  },
+  t => [
+    unique('account_handle_idx').on(t.handle),
+    index('account_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(),
+    accepted: boolean().default(false).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 +157,15 @@ 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',
+  'transferHandle',
+]);
 
 export const NotificationTable = pgTable(
   'notifications',
@@ -166,4 +202,6 @@ export const tables = [
   'state',
   'authrequests',
   'ratelimits',
+  'handle',
+  'handle_transfer',
 ];

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

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

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 { AccountTable, FeedTable } from '../../drizzle/schema';
 
 const statement = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    author_handle: AccountTable.handle,
+    author_display: AccountTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.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 { AccountTable, FollowsTable } from '../../drizzle/schema';
 
 const statementGetFollowers = getDatabase()
-  .select({ address: FollowsTable.follower, hash: FollowsTable.hash })
+  .select({
+    address: FollowsTable.follower,
+    handle: AccountTable.handle,
+    display: AccountTable.display,
+    hash: FollowsTable.hash,
+  })
   .from(FollowsTable)
+  .leftJoin(AccountTable, eq(AccountTable.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 { AccountTable, FollowsTable } from '../../drizzle/schema';
 
 const statementGetFollowing = getDatabase()
-  .select({ address: FollowsTable.following, hash: FollowsTable.hash })
+  .select({
+    address: FollowsTable.following,
+    handle: AccountTable.handle,
+    display: AccountTable.display,
+    hash: FollowsTable.hash,
+  })
   .from(FollowsTable)
+  .leftJoin(AccountTable, eq(AccountTable.address, FollowsTable.following))
   .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/index.ts

@@ -1,3 +1,4 @@
+export * from './account';
 export * from './authVerify';
 export * from './dislikes';
 export * from './feed';

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

@@ -1,19 +1,29 @@
 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 { AccountTable, FeedTable } from '../../drizzle/schema';
 
 const statementGetPost = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    author_handle: AccountTable.handle,
+    author_display: AccountTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.address))
   .where(and(isNull(FeedTable.removed_at), eq(FeedTable.hash, sql.placeholder('hash'))))
   .prepare('stmnt_get_post');
 
 const statementGetReply = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    author_handle: AccountTable.handle,
+    author_display: AccountTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.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 { AccountTable, FeedTable, FollowsTable } from '../../drizzle/schema';
 
 const statement = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    author_handle: AccountTable.handle,
+    author_display: AccountTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.address))
   .where(
     and(
       eq(FeedTable.author, sql.placeholder('author')),
@@ -48,8 +53,13 @@ export async function Posts(query: Gets.PostsQuery) {
 }
 
 const followingPostsStatement = getDatabase()
-  .select()
+  .select({
+    ...getTableColumns(FeedTable),
+    author_handle: AccountTable.handle,
+    author_display: AccountTable.display,
+  })
   .from(FeedTable)
+  .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.address))
   .where(
     and(
       inArray(FeedTable.author, getDatabase()

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 { AccountTable, FeedTable } 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(AccountTable, eq(FeedTable.author, AccountTable.address))
+      .where(
+        and(
+          or(
+            eq(FeedTable.author, query.text.toLowerCase()), // Exact address
+            ilike(AccountTable.handle, `%${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),
+        author_handle: AccountTable.handle,
+        author_display: AccountTable.display,
+      })
       .from(FeedTable)
+      .leftJoin(AccountTable, eq(FeedTable.author, AccountTable.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);