tapimo 0.5.2 → 0.6.0

package/src/admin/App.ts

@@ -11,6 +11,7 @@ import type * as Store from '../internal/Store.js'
 import * as Response from '../internal/Response.js'
 
 import { apiKeys } from './apps/api-keys.js'
+import { earlyAccess } from './apps/early-access.js'
 import { organizations } from './apps/organizations.js'
 import { scopes } from './apps/scopes.js'
 import { verifiedTokens } from './apps/verified-tokens.js'
@@ -117,6 +118,8 @@ export function create(options: create.Options) {
     '/config.json',
     '/api-keys',
     '/api-keys/*',
+    '/early-access',
+    '/early-access/*',
     '/organizations',
     '/organizations/*',
     '/scopes',
@@ -152,6 +155,7 @@ export function create(options: create.Options) {
   const routed = app
     .get('/config.json', (c) => c.json(authConfig(c.get('identity')), 200))
     .route('/api-keys', apiKeys())
+    .route('/early-access', earlyAccess())
     .route('/organizations', organizations())
     .route('/scopes', scopes())
     .route('/verified-tokens', verifiedTokens())

package/src/admin/apps/early-access.test.ts

@@ -0,0 +1,125 @@
+import * as TestAdmin from '../../../test/Admin.js'
+import * as TestApp from '../../../test/App.js'
+import * as EarlyAccessApp from './early-access.js'
+
+/** Lists the table's entries. */
+async function listAdded(client: ReturnType<typeof TestAdmin.setup>['client']) {
+  const response = await client['early-access'].$get()
+  const body = await TestApp.json(response, EarlyAccessApp.schema.listEarlyAccessEntries.Response)
+  return body.data
+}
+
+describe('authentication', () => {
+  test('denied identity → 401 on every route', async () => {
+    const { app } = TestAdmin.setup({ identify: () => null })
+    const routes = [
+      new Request('http://admin/early-access'),
+      new Request('http://admin/early-access', {
+        body: JSON.stringify({ entry: 'example.org' }),
+        headers: { 'content-type': 'application/json' },
+        method: 'POST',
+      }),
+      new Request('http://admin/early-access', {
+        body: JSON.stringify({ entry: 'example.org' }),
+        headers: { 'content-type': 'application/json' },
+        method: 'DELETE',
+      }),
+    ]
+    for (const request of routes) {
+      const response = await app.request(request)
+      expect(response.status).toBe(401)
+    }
+  })
+})
+
+describe('GET /early-access', () => {
+  test('starts empty; entries are seeded through the dash, never migrations', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client['early-access'].$get()
+    const body = await TestApp.json(response, EarlyAccessApp.schema.listEarlyAccessEntries.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data).toEqual([])
+  })
+})
+
+describe('POST /early-access', () => {
+  test('add → list → remove round-trip', async () => {
+    const { client } = TestAdmin.setup()
+
+    const created = await client['early-access'].$post({ json: { entry: 'a/b@example.org' } })
+    expect(created.status).toBe(200)
+    const body = await TestApp.json(created, EarlyAccessApp.schema.createEarlyAccessEntry.Response)
+    expect(body.data.entry).toBe('a/b@example.org')
+    // createdBy is the verified admin email, never client-supplied.
+    expect(body.data.createdBy).toBe(TestAdmin.identity.email)
+
+    expect((await listAdded(client)).map((record) => record.entry)).toEqual(['a/b@example.org'])
+
+    // Reserved URL characters stay in the JSON body.
+    const removed = await client['early-access'].$delete({ json: { entry: 'a/b@example.org' } })
+    expect(removed.status).toBe(200)
+    expect(await listAdded(client)).toEqual([])
+  })
+
+  test('normalizes the entry lowercase and trimmed', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client['early-access'].$post({ json: { entry: '  User@Example.ORG ' } })
+    const body = await TestApp.json(response, EarlyAccessApp.schema.createEarlyAccessEntry.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data.entry).toBe('user@example.org')
+  })
+
+  test('rejects an invalid entry with 400', async () => {
+    const { client } = TestAdmin.setup()
+    for (const entry of ['', '   ', 'no spaces.org x', 'not-a-domain', '@example.org', 'user@']) {
+      const response = await client['early-access'].$post({ json: { entry } })
+      const body = (await response.json()) as { error?: { code?: string } }
+      expect(response.status).toBe(400)
+      expect(body.error?.code).toBe('body_invalid')
+    }
+  })
+
+  test('rejects a duplicate entry with 409', async () => {
+    const { client } = TestAdmin.setup()
+    await client['early-access'].$post({ json: { entry: 'example.org' } })
+    const duplicate = await client['early-access'].$post({ json: { entry: 'Example.org' } })
+    const body = (await duplicate.json()) as { error?: { code?: string } }
+
+    expect(duplicate.status).toBe(409)
+    expect(body.error?.code).toBe('entry_exists')
+  })
+})
+
+describe('DELETE /early-access', () => {
+  test('removing an unknown entry → 404', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client['early-access'].$delete({
+      json: { entry: 'missing.example.org' },
+    })
+    const body = (await response.json()) as { error?: { code?: string } }
+
+    expect(response.status).toBe(404)
+    expect(body.error?.code).toBe('entry_not_found')
+  })
+})
+
+describe('audit logging', () => {
+  test('writes an audit row for allowlist mutations', async () => {
+    const { client, db } = TestAdmin.setup()
+    await client['early-access'].$post({ json: { entry: 'example.org' } })
+    const records = await db.kysely
+      .selectFrom('admin_audit_logs')
+      .selectAll()
+      .orderBy('createdAt', 'desc')
+      .execute()
+
+    expect(records[0]).toMatchObject({
+      actor: TestAdmin.identity.email,
+      method: 'POST',
+      path: '/early-access',
+      status: 200,
+    })
+  })
+})

package/src/admin/apps/early-access.ts

@@ -0,0 +1,175 @@
+import { Hono } from 'hono'
+import * as z from 'zod/mini'
+
+import * as Db from '../../db/Db.js'
+import * as db_Schema from '../../db/Schema.js'
+import * as EarlyAccess from '../../db/tables/earlyAccess.js'
+import * as OpenApi from '../../internal/OpenApi.js'
+import * as Response from '../../internal/Response.js'
+import * as Schema from '../../internal/Schema.js'
+import type * as App from '../App.js'
+
+// A bare domain (`example.org`) or a full email (`user@example.org`), matched
+// after the trim/lowercase transforms below.
+const entryPattern =
+  /^(?:[^\s@]+@)?[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/
+
+/** Zod schemas owned by the admin early-access handler. */
+export namespace schema {
+  /** A stored early-access allowlist entry (the `early_access` row shape). */
+  export const Entry = Schema.describe(
+    db_Schema.EarlyAccessEntry,
+    'A stored early-access allowlist entry.',
+  )
+
+  /** Schemas for the listEarlyAccessEntries operation. */
+  export namespace listEarlyAccessEntries {
+    /** Response body: all allowlist entries. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z.array(Entry).check(z.describe('Allowlist entries, ordered by entry.')),
+      }),
+      'Early-access allowlist entries.',
+    )
+  }
+
+  /** Schemas for the createEarlyAccessEntry operation. */
+  export namespace createEarlyAccessEntry {
+    /** Request body for adding an allowlist entry. */
+    export const Body = z
+      .object({
+        entry: z.string().check(
+          z.trim(),
+          z.toLowerCase(),
+          z.regex(entryPattern, 'Must be a bare domain (example.org) or a full email (user@example.org).'), // prettier-ignore
+          z.describe('Domain or exact email to grant early access; normalized lowercase.'),
+        ),
+      })
+      .check(z.describe('Request body for adding an allowlist entry.'))
+
+    /** Response body: the stored entry. */
+    export const Response = Schema.describe(
+      z.object({ data: Entry }),
+      'The stored allowlist entry.',
+    )
+  }
+
+  /** Schemas for the deleteEarlyAccessEntry operation. */
+  export namespace deleteEarlyAccessEntry {
+    /** Request body addressing one allowlist entry. */
+    export const Body = z
+      .object({
+        entry: z.string().check(
+          z.trim(),
+          z.toLowerCase(),
+          z.regex(entryPattern, 'Must be a bare domain (example.org) or a full email (user@example.org).'), // prettier-ignore
+          z.describe('The allowlist entry to remove; normalized lowercase.'),
+        ),
+      })
+      .check(z.describe('Request body for removing an allowlist entry.'))
+
+    /** Response body: the removed entry. */
+    export const Response = Schema.describe(
+      z.object({ data: Entry }),
+      'The removed allowlist entry.',
+    )
+  }
+}
+
+/**
+ * Management routes for the temporary early-access allowlist (`early_access`
+ * table): entries are lowercase domains or exact emails.
+ *
+ * - `GET /` lists entries.
+ * - `POST /` adds an entry (`409` on a duplicate).
+ * - `DELETE /` removes an entry (`404` if absent).
+ */
+export function earlyAccess() {
+  return new Hono<App.Environment>()
+    .get(
+      '/',
+      OpenApi.describeRoute({
+        operationId: 'listEarlyAccessEntries',
+        responses: OpenApi.responses({
+          success: {
+            description: 'Early-access allowlist entries.',
+            schema: schema.listEarlyAccessEntries.Response,
+          },
+        }),
+        summary: 'List early access',
+        tags: ['Early Access'],
+      }),
+      async (c) => {
+        const db = Db.get(c.get('db'))
+        return c.json(
+          Response.validated(schema.listEarlyAccessEntries.Response, {
+            data: await EarlyAccess.list(db),
+          }),
+        )
+      },
+    )
+    .post(
+      '/',
+      OpenApi.validate('json', schema.createEarlyAccessEntry.Body, {
+        code: 'body_invalid',
+        message: 'Invalid request body',
+      }),
+      OpenApi.describeRoute({
+        operationId: 'createEarlyAccessEntry',
+        responses: OpenApi.responses({
+          errors: { 409: 'Entry already exists.' },
+          success: {
+            description: 'The stored allowlist entry.',
+            schema: schema.createEarlyAccessEntry.Response,
+          },
+        }),
+        summary: 'Add early-access entry',
+        tags: ['Early Access'],
+      }),
+      async (c) => {
+        const db = Db.get(c.get('db'))
+        const { entry } = c.req.valid('json')
+        // `createdBy` is the verified admin email; `requireAuth` guarantees
+        // identity on this gated route.
+        const record = await EarlyAccess.add(db, { createdBy: c.get('identity')!.email, entry })
+        if (!record)
+          return Response.error(c, {
+            code: 'entry_exists',
+            message: 'Entry already exists.',
+            status: 409,
+          })
+        return c.json(Response.validated(schema.createEarlyAccessEntry.Response, { data: record }))
+      },
+    )
+    .delete(
+      '/',
+      OpenApi.validate('json', schema.deleteEarlyAccessEntry.Body, {
+        code: 'body_invalid',
+        message: 'Invalid request body',
+      }),
+      OpenApi.describeRoute({
+        operationId: 'deleteEarlyAccessEntry',
+        responses: OpenApi.responses({
+          errors: { 404: 'Entry not found.' },
+          success: {
+            description: 'The removed allowlist entry.',
+            schema: schema.deleteEarlyAccessEntry.Response,
+          },
+        }),
+        summary: 'Remove early-access entry',
+        tags: ['Early Access'],
+      }),
+      async (c) => {
+        const db = Db.get(c.get('db'))
+        const { entry } = c.req.valid('json')
+        const record = await EarlyAccess.remove(db, entry)
+        if (!record)
+          return Response.error(c, {
+            code: 'entry_not_found',
+            message: 'Entry not found.',
+            status: 404,
+          })
+        return c.json(Response.validated(schema.deleteEarlyAccessEntry.Response, { data: record }))
+      },
+    )
+}

package/src/admin/apps/verified-tokens.test.ts

@@ -1,5 +1,7 @@
 import * as TestAdmin from '../../../test/Admin.js'
 import * as TestApp from '../../../test/App.js'
+import * as Organizations from '../../db/tables/organizations.js'
+import * as VerifiedTokenRequests from '../../db/tables/verifiedTokenRequests.js'
 import * as Verified from './verified-tokens.js'
 
 /** A token used for write round-trips. */
@@ -338,6 +340,205 @@ describe('PUT /verified-tokens/:address/logo', () => {
   })
 })
 
+/** A stored verification request seeded through the repo write boundary. */
+const requestInput = {
+  address: '0x20c00000000000000000000000000000000000aa',
+  chainId: 42431,
+  currency: 'USD',
+  decimals: 6,
+  name: 'Requested USD',
+  orgId: 'org_1a2b3c4d5e6f7g8h9j0k1m2n',
+  requestedBy: 'usr_1a2b3c4d5e6f7g8h9j0k1m2n',
+  symbol: 'rUSD',
+} as const
+
+describe('GET /verified-tokens/requests', () => {
+  test('denied identity → 401', async () => {
+    const { client } = TestAdmin.setup({ identify: () => null })
+    const response = await client['verified-tokens'].requests.$get({ query: {} })
+    expect(response.status).toBe(401)
+  })
+
+  test('lists the queue by status with org names', async () => {
+    const { client, db } = TestAdmin.setup()
+    const org = await Organizations.create(db, { name: 'Acme' })
+    const pending = await VerifiedTokenRequests.create(db, {
+      ...requestInput,
+      logo: '<svg xmlns="http://www.w3.org/2000/svg"/>',
+      orgId: org.id,
+    })
+    const denied = await VerifiedTokenRequests.create(db, {
+      ...requestInput,
+      address: '0x20c00000000000000000000000000000000000bb',
+      symbol: 'rEUR',
+    })
+    await VerifiedTokenRequests.review(db, denied!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+
+    const queue = await client['verified-tokens'].requests.$get({ query: {} })
+    expect(queue.status).toBe(200)
+    const queueBody = await TestApp.json(queue, Verified.schema.listVerifiedTokenRequests.Response)
+    expect(queueBody.data.map(({ id, orgName }) => ({ id, orgName }))).toEqual([
+      { id: pending!.id, orgName: 'Acme' },
+    ])
+    // The uploaded SVG surfaces to reviewers.
+    expect(queueBody.data[0]?.logo).toBe('<svg xmlns="http://www.w3.org/2000/svg"/>')
+
+    const reviewed = await client['verified-tokens'].requests.$get({ query: { status: 'denied' } })
+    const reviewedBody = await TestApp.json(reviewed, Verified.schema.listVerifiedTokenRequests.Response) // prettier-ignore
+    expect(reviewedBody.data.map(({ id }) => id)).toEqual([denied!.id])
+  })
+})
+
+describe('POST /verified-tokens/requests/:requestId/approve', () => {
+  test('publishes the token and stamps the review', async () => {
+    const { client, db } = TestAdmin.setup()
+    const org = await Organizations.create(db, { name: 'Acme' })
+    const request = await VerifiedTokenRequests.create(db, { ...requestInput, orgId: org.id })
+
+    const approved = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(approved.status).toBe(200)
+    const body = await TestApp.json(approved, Verified.schema.reviewVerifiedTokenRequest.Response)
+    expect(body.data).toMatchObject({
+      orgName: 'Acme',
+      reviewedBy: TestAdmin.identity.email,
+      status: 'approved',
+    })
+    expect(Date.parse(body.data.reviewedAt!)).not.toBeNaN()
+
+    const listed = await client['verified-tokens'].$get({ query: { chainId } })
+    const listedBody = await TestApp.json(listed, Verified.schema.listVerifiedTokens.Response)
+    expect(listedBody.data.map(({ address }) => address)).toEqual([requestInput.address])
+
+    const repeat = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(repeat.status).toBe(409)
+    const repeatBody = (await repeat.json()) as { error?: { code?: string } }
+    expect(repeatBody.error?.code).toBe('request_not_pending')
+  })
+
+  test('publishes an uploaded logo to the asset store', async () => {
+    const svg = '<svg xmlns="http://www.w3.org/2000/svg"/>'
+    const stored: { key: string; content: { body: ArrayBuffer; contentType: string } }[] = []
+    const { client, db } = TestAdmin.setup({
+      assets: {
+        get: async (key) => stored.find((entry) => entry.key === key)?.content,
+        put: async (key, content) => void stored.push({ content, key }),
+      },
+    })
+    const request = await VerifiedTokenRequests.create(db, { ...requestInput, logo: svg })
+
+    const approved = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(approved.status).toBe(200)
+    expect(stored).toHaveLength(1)
+    expect(stored[0]?.key).toBe(`42431/icons/${requestInput.address}`)
+    expect(new TextDecoder().decode(stored[0]?.content.body)).toBe(svg)
+
+    const listed = await client['verified-tokens'].$get({ query: { chainId } })
+    const listedBody = await TestApp.json(listed, Verified.schema.listVerifiedTokens.Response)
+    expect(listedBody.data.map(({ address }) => address)).toEqual([requestInput.address])
+  })
+
+  test('rejects an uploaded logo without an asset writer, keeping the request pending', async () => {
+    const { client, db } = TestAdmin.setup()
+    const request = await VerifiedTokenRequests.create(db, {
+      ...requestInput,
+      logo: '<svg xmlns="http://www.w3.org/2000/svg"/>',
+    })
+
+    const approved = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(approved.status).toBe(404)
+    const body = (await approved.json()) as { error?: { code?: string } }
+    expect(body.error?.code).toBe('assets_not_enabled')
+
+    const record = await VerifiedTokenRequests.get(db, request!.id)
+    expect(record?.status).toBe('pending')
+  })
+
+  test('converges when the token is already verified', async () => {
+    const { client, db } = TestAdmin.setup()
+    const request = await VerifiedTokenRequests.create(db, requestInput)
+    await client['verified-tokens'].$post({
+      json: { ...novel, address: requestInput.address, chainId: 42431, symbol: requestInput.symbol }, // prettier-ignore
+    })
+
+    const approved = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(approved.status).toBe(200)
+    const body = await TestApp.json(approved, Verified.schema.reviewVerifiedTokenRequest.Response)
+    expect(body.data.status).toBe('approved')
+
+    // The pre-existing entry survives untouched; nothing was re-created.
+    const listed = await client['verified-tokens'].$get({ query: { chainId } })
+    const listedBody = await TestApp.json(listed, Verified.schema.listVerifiedTokens.Response)
+    expect(listedBody.data).toHaveLength(1)
+  })
+
+  test('rejects a symbol conflict and keeps the request pending', async () => {
+    const { client, db } = TestAdmin.setup()
+    // Same symbol already verified under a different address.
+    await client['verified-tokens'].$post({
+      json: { ...novel, chainId: 42431, symbol: requestInput.symbol },
+    })
+    const request = await VerifiedTokenRequests.create(db, requestInput)
+
+    const approved = await client['verified-tokens'].requests[':requestId'].approve.$post({
+      param: { requestId: request!.id },
+    })
+    expect(approved.status).toBe(409)
+    const body = (await approved.json()) as { error?: { code?: string } }
+    expect(body.error?.code).toBe('duplicate_symbol')
+
+    const record = await VerifiedTokenRequests.get(db, request!.id)
+    expect(record?.status).toBe('pending')
+  })
+})
+
+describe('POST /verified-tokens/requests/:requestId/deny', () => {
+  test('records the review note', async () => {
+    const { client, db } = TestAdmin.setup()
+    const request = await VerifiedTokenRequests.create(db, requestInput)
+
+    const denied = await client['verified-tokens'].requests[':requestId'].deny.$post({
+      json: { reviewNote: 'Logo unreachable.' },
+      param: { requestId: request!.id },
+    })
+    expect(denied.status).toBe(200)
+    const body = await TestApp.json(denied, Verified.schema.reviewVerifiedTokenRequest.Response)
+    expect(body.data).toMatchObject({
+      reviewNote: 'Logo unreachable.',
+      reviewedBy: TestAdmin.identity.email,
+      status: 'denied',
+    })
+
+    // Nothing was published.
+    const listed = await client['verified-tokens'].$get({ query: { chainId } })
+    const listedBody = await TestApp.json(listed, Verified.schema.listVerifiedTokens.Response)
+    expect(listedBody.data).toEqual([])
+  })
+
+  test('unknown request id → 404', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client['verified-tokens'].requests[':requestId'].deny.$post({
+      json: {},
+      param: { requestId: 'vtr_1a2b3c4d5e6f7g8h9j0k1m2n' },
+    })
+    expect(response.status).toBe(404)
+    const body = (await response.json()) as { error?: { code?: string } }
+    expect(body.error?.code).toBe('verified_token_request_not_found')
+  })
+})
+
 describe('GET /verified-tokens/:address/logo', () => {
   const svg = '<svg xmlns="http://www.w3.org/2000/svg"/>'