tapimo 0.5.3 → 0.7.0

package/src/db/tables/sponsoredTransactions.ts

@@ -397,6 +397,7 @@ export async function usage(db: Db.Db, options: usage.Options): Promise<usage.Bu
     .select([
       sql<string>`to_char(${bucket}, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as('timestamp'),
       sql<string>`count(*)`.as('count'),
+      sql<string>`count(*) filter (where status = 'failed')`.as('failed'),
       sql<string>`coalesce(sum(case when status = 'finalized' then fee_amount::numeric when status = 'pending' then fee_max::numeric else 0 end), 0)`.as('feeTotal'), // prettier-ignore
     ])
     .where('orgId', '=', orgId)
@@ -410,6 +411,7 @@ export async function usage(db: Db.Db, options: usage.Options): Promise<usage.Bu
   const rows = await query.execute()
   return rows.map((row) => ({
     count: Number(row.count),
+    failed: Number(row.failed),
     feeTotal: BigInt(row.feeTotal),
     timestamp: row.timestamp,
   }))
@@ -420,6 +422,8 @@ export declare namespace usage {
   type Bucket = {
     /** Sponsored transactions recorded in the bucket, any status. */
     count: number
+    /** Sponsored transactions in the bucket whose status is `failed`. */
+    failed: number
     /** Committed fees in fee-token base units: finalized fees plus pending caps. */
     feeTotal: bigint
     /** Bucket start (ISO 8601), aligned to UTC calendar boundaries. */

package/src/db/tables/verifiedTokenRequests.test.ts

@@ -0,0 +1,200 @@
+import * as TestApp from '../../../test/App.js'
+import * as Organizations from './organizations.js'
+import * as VerifiedTokenRequests from './verifiedTokenRequests.js'
+
+const input = {
+  address: '0x20c00000000000000000000000000000000000aa',
+  chainId: 42431,
+  currency: 'USD',
+  decimals: 6,
+  name: 'Test USD',
+  orgId: 'org_1a2b3c4d5e6f7g8h9j0k1m2n',
+  requestedBy: 'usr_1a2b3c4d5e6f7g8h9j0k1m2n',
+  symbol: 'tUSD',
+} as const
+
+describe('create', () => {
+  test('inserts a pending request', async () => {
+    const db = TestApp.database()
+    const record = await VerifiedTokenRequests.create(db, { ...input, note: 'We are the issuer.' })
+    expect(record).toBeDefined()
+    const { createdAt, id, updatedAt, ...rest } = record!
+    expect(id).toMatch(/^vtr_/)
+    expect(Date.parse(createdAt)).not.toBeNaN()
+    expect(updatedAt).toBe(createdAt)
+    expect(rest).toMatchInlineSnapshot(`
+      {
+        "address": "0x20c00000000000000000000000000000000000aa",
+        "chainId": 42431,
+        "currency": "USD",
+        "decimals": 6,
+        "logo": null,
+        "logoUri": null,
+        "name": "Test USD",
+        "note": "We are the issuer.",
+        "orgId": "org_1a2b3c4d5e6f7g8h9j0k1m2n",
+        "requestedBy": "usr_1a2b3c4d5e6f7g8h9j0k1m2n",
+        "reviewNote": null,
+        "reviewedAt": null,
+        "reviewedBy": null,
+        "status": "pending",
+        "symbol": "tUSD",
+      }
+    `)
+  })
+
+  test('a duplicate pending (chain, address) yields undefined, even cross-org', async () => {
+    const db = TestApp.database()
+    await VerifiedTokenRequests.create(db, input)
+    const duplicate = await VerifiedTokenRequests.create(db, {
+      ...input,
+      orgId: 'org_2b3c4d5e6f7g8h9j0k1m2n3p',
+    })
+    expect(duplicate).toBeUndefined()
+  })
+
+  test('a reviewed request frees the (chain, address) slot', async () => {
+    const db = TestApp.database()
+    const first = await VerifiedTokenRequests.create(db, input)
+    await VerifiedTokenRequests.review(db, first!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+    const second = await VerifiedTokenRequests.create(db, input)
+    expect(second).toBeDefined()
+  })
+
+  test('the same address on another chain is independent', async () => {
+    const db = TestApp.database()
+    await VerifiedTokenRequests.create(db, input)
+    const other = await VerifiedTokenRequests.create(db, { ...input, chainId: 4217 })
+    expect(other).toBeDefined()
+  })
+})
+
+describe('list', () => {
+  test('returns only the organization, newest first', async () => {
+    const db = TestApp.database()
+    const first = await VerifiedTokenRequests.create(db, input)
+    const second = await VerifiedTokenRequests.create(db, {
+      ...input,
+      address: '0x20c00000000000000000000000000000000000bb',
+      symbol: 'tEUR',
+    })
+    await VerifiedTokenRequests.create(db, {
+      ...input,
+      address: '0x20c00000000000000000000000000000000000cc',
+      orgId: 'org_2b3c4d5e6f7g8h9j0k1m2n3p',
+      symbol: 'tGBP',
+    })
+    const records = await VerifiedTokenRequests.list(db, input.orgId)
+    expect(records.map(({ id }) => id).sort()).toEqual([first!.id, second!.id].sort())
+    expect(records.every(({ orgId }) => orgId === input.orgId)).toBe(true)
+  })
+})
+
+describe('listByStatus', () => {
+  test('filters by status and joins the current org name', async () => {
+    const db = TestApp.database()
+    const org = await Organizations.create(db, { name: 'Acme' })
+    const pending = await VerifiedTokenRequests.create(db, { ...input, orgId: org.id })
+    const denied = await VerifiedTokenRequests.create(db, {
+      ...input,
+      address: '0x20c00000000000000000000000000000000000bb',
+      symbol: 'tEUR',
+    })
+    await VerifiedTokenRequests.review(db, denied!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+
+    const queue = await VerifiedTokenRequests.listByStatus(db, 'pending')
+    expect(queue.map(({ id, orgName }) => ({ id, orgName }))).toEqual([
+      { id: pending!.id, orgName: 'Acme' },
+    ])
+    // The denied row's org has no organizations row; the join yields null.
+    const reviewed = await VerifiedTokenRequests.listByStatus(db, 'denied')
+    expect(reviewed.map(({ id, orgName }) => ({ id, orgName }))).toEqual([
+      { id: denied!.id, orgName: null },
+    ])
+  })
+})
+
+describe('countPending', () => {
+  test('counts only the organization pending requests', async () => {
+    const db = TestApp.database()
+    await VerifiedTokenRequests.create(db, input)
+    const denied = await VerifiedTokenRequests.create(db, {
+      ...input,
+      address: '0x20c00000000000000000000000000000000000bb',
+      symbol: 'tEUR',
+    })
+    await VerifiedTokenRequests.review(db, denied!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+    await VerifiedTokenRequests.create(db, {
+      ...input,
+      address: '0x20c00000000000000000000000000000000000cc',
+      orgId: 'org_2b3c4d5e6f7g8h9j0k1m2n3p',
+      symbol: 'tGBP',
+    })
+    expect(await VerifiedTokenRequests.countPending(db, input.orgId)).toBe(1)
+  })
+})
+
+describe('remove', () => {
+  test('deletes only in-org pending requests', async () => {
+    const db = TestApp.database()
+    const record = await VerifiedTokenRequests.create(db, input)
+    expect(
+      await VerifiedTokenRequests.remove(db, 'org_2b3c4d5e6f7g8h9j0k1m2n3p', record!.id),
+    ).toBeUndefined()
+    expect(await VerifiedTokenRequests.remove(db, input.orgId, record!.id)).toBeDefined()
+    expect(await VerifiedTokenRequests.get(db, record!.id)).toBeUndefined()
+  })
+
+  test('leaves reviewed requests in place', async () => {
+    const db = TestApp.database()
+    const record = await VerifiedTokenRequests.create(db, input)
+    await VerifiedTokenRequests.review(db, record!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'approved',
+    })
+    expect(await VerifiedTokenRequests.remove(db, input.orgId, record!.id)).toBeUndefined()
+    expect(await VerifiedTokenRequests.get(db, record!.id)).toBeDefined()
+  })
+})
+
+describe('review', () => {
+  test('marks a pending request with reviewer identity', async () => {
+    const db = TestApp.database()
+    const record = await VerifiedTokenRequests.create(db, input)
+    const reviewed = await VerifiedTokenRequests.review(db, record!.id, {
+      reviewNote: 'Logo unreachable.',
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+    expect(reviewed).toMatchObject({
+      reviewNote: 'Logo unreachable.',
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'denied',
+    })
+    expect(Date.parse(reviewed!.reviewedAt!)).not.toBeNaN()
+  })
+
+  test('yields undefined once reviewed', async () => {
+    const db = TestApp.database()
+    const record = await VerifiedTokenRequests.create(db, input)
+    await VerifiedTokenRequests.review(db, record!.id, {
+      reviewedBy: 'admin@tempo.xyz',
+      status: 'approved',
+    })
+    expect(
+      await VerifiedTokenRequests.review(db, record!.id, {
+        reviewedBy: 'admin@tempo.xyz',
+        status: 'denied',
+      }),
+    ).toBeUndefined()
+  })
+})

package/src/db/tables/verifiedTokenRequests.ts

@@ -0,0 +1,182 @@
+import { type Selectable, sql } from 'kysely'
+
+import * as Id from '../../internal/Id.js'
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `verified_token_requests` table. */
+export type Table = db_Schema.VerifiedTokenRequest
+/** A stored verification request. */
+export type Record = Selectable<Table>
+/** Review status of a request. */
+export type Status = Record['status']
+
+/**
+ * Inserts a pending request; `undefined` when a pending request for
+ * (chainId, address) already exists.
+ */
+export function create(db: Db.Db, input: create.Input): Promise<Record | undefined> {
+  const now = new Date().toISOString()
+  return db.kysely
+    .insertInto('verified_token_requests')
+    .values({
+      address: input.address,
+      chainId: input.chainId,
+      createdAt: now,
+      currency: input.currency,
+      decimals: input.decimals,
+      id: Id.generate('vtr'),
+      logo: input.logo ?? null,
+      logoUri: input.logoUri ?? null,
+      name: input.name,
+      note: input.note ?? null,
+      orgId: input.orgId,
+      requestedBy: input.requestedBy,
+      reviewNote: null,
+      reviewedAt: null,
+      reviewedBy: null,
+      status: 'pending',
+      symbol: input.symbol,
+      updatedAt: now,
+    })
+    .onConflict((oc) =>
+      oc
+        .columns(['chainId', 'address'])
+        // `sql.lit` keeps the predicate literal; a bound parameter would
+        // defeat partial-index inference for the conflict target.
+        .where('status', '=', sql.lit('pending'))
+        .doNothing(),
+    )
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace create {
+  /** Fields accepted when inserting a request. */
+  type Input = {
+    /** Requested token contract address (lowercase). */
+    address: string
+    /** Chain the token belongs to. */
+    chainId: number
+    /** Display currency, e.g. `USD`. */
+    currency: string
+    /** Decimal precision. */
+    decimals: number
+    /** Inline SVG logo markup uploaded by the requester. */
+    logo?: string | undefined
+    /** HTTPS logo URL from chain metadata. */
+    logoUri?: string | undefined
+    /** Display name. */
+    name: string
+    /** Requester note to reviewers. */
+    note?: string | undefined
+    /** Requesting organization id (`org_…`). */
+    orgId: string
+    /** User id that submitted the request, or `super_admin`. */
+    requestedBy: string
+    /** Ticker symbol. */
+    symbol: string
+  }
+}
+
+/** Lists an organization's requests, newest first. */
+export function list(db: Db.Db, orgId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('verified_token_requests')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .orderBy('createdAt', 'desc')
+    .execute()
+}
+
+/**
+ * Lists requests in one status globally, oldest first (review-queue order),
+ * with the requesting organization's current name when it still exists.
+ */
+export function listByStatus(
+  db: Db.Db,
+  status: Status,
+): Promise<(Record & { orgName: string | null })[]> {
+  return db.kysely
+    .selectFrom('verified_token_requests')
+    .leftJoin('organizations', 'organizations.id', 'verified_token_requests.orgId')
+    .selectAll('verified_token_requests')
+    .select('organizations.name as orgName')
+    .where('status', '=', status)
+    .orderBy('verified_token_requests.createdAt', 'asc')
+    .execute()
+}
+
+/** Gets a request by id. */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('verified_token_requests')
+    .selectAll()
+    .where('id', '=', id)
+    .executeTakeFirst()
+}
+
+/** Counts an organization's pending requests. */
+export async function countPending(db: Db.Db, orgId: string): Promise<number> {
+  const row = await db.kysely
+    .selectFrom('verified_token_requests')
+    .select(({ fn }) => fn.countAll<string>().as('count'))
+    .where('orgId', '=', orgId)
+    .where('status', '=', 'pending')
+    .executeTakeFirstOrThrow()
+  return Number(row.count)
+}
+
+/** Hard-deletes an org-scoped request while pending; `undefined` otherwise. */
+export function remove(db: Db.Db, orgId: string, id: string): Promise<Record | undefined> {
+  return db.kysely
+    .deleteFrom('verified_token_requests')
+    .where('id', '=', id)
+    .where('orgId', '=', orgId)
+    .where('status', '=', 'pending')
+    .returningAll()
+    .executeTakeFirst()
+}
+
+/**
+ * Marks a pending request approved or denied with reviewer identity;
+ * `undefined` when absent or already reviewed.
+ */
+export function review(db: Db.Db, id: string, input: review.Input): Promise<Record | undefined> {
+  const now = new Date().toISOString()
+  return db.kysely
+    .updateTable('verified_token_requests')
+    .set({
+      reviewNote: input.reviewNote ?? null,
+      reviewedAt: now,
+      reviewedBy: input.reviewedBy,
+      status: input.status,
+      updatedAt: now,
+    })
+    .where('id', '=', id)
+    .where('status', '=', 'pending')
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace review {
+  /** Review outcome fields. */
+  type Input = {
+    /** Reviewer note shown on denial. */
+    reviewNote?: string | undefined
+    /** Reviewing admin email. */
+    reviewedBy: string
+    /** Review outcome. */
+    status: 'approved' | 'denied'
+  }
+}
+
+/** Maps a stored row to the wire shape (null `logo`/`logoUri` map to absent). */
+export function toRequest(record: Record) {
+  const { logo, logoUri, ...rest } = record
+  return {
+    ...rest,
+    ...(logo === null ? {} : { logo }),
+    ...(logoUri === null ? {} : { logoUri }),
+  }
+}

package/src/db/tables/webhookSubscriptions.ts

@@ -5,6 +5,8 @@ import type * as Webhooks from '../../internal/Webhooks.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
 
+const subscriptionLimitLockClass = 1464353612
+
 /** Columns of the `webhook_subscriptions` table, derived from `Schema.WebhookSubscription`. */
 export type Table = db_Schema.WebhookSubscription
 
@@ -69,6 +71,35 @@ export async function insert(db: Db.Db, subscription: Webhooks.Subscription): Pr
     .execute()
 }
 
+/**
+ * Inserts a subscription when its owner remains below the configured cap.
+ * An owner-scoped transaction lock serializes the count and insert.
+ */
+export async function insertWithinLimit(
+  db: Db.Db,
+  subscription: Webhooks.Subscription,
+  options: insertWithinLimit.Options,
+): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const owner = `${subscription.owner.type}:${ownerId(subscription.owner)}`
+    await sql`select pg_advisory_xact_lock(${subscriptionLimitLockClass}, hashtext(${owner}))`.execute(tx.kysely) // prettier-ignore
+    const existing = await count(tx, subscription.owner, options.now)
+    if (existing >= options.maxPerOwner) return false
+    await insert(tx, subscription)
+    return true
+  })
+}
+
+export declare namespace insertWithinLimit {
+  /** Options for an atomic capped insert. */
+  type Options = {
+    /** Maximum live subscriptions the owner may hold. */
+    maxPerOwner: number
+    /** ISO timestamp used to exclude expired rows from the count. */
+    now: string
+  }
+}
+
 /**
  * Reads an owner's subscription by id; expired rows never match (query-time
  * expiry, same read semantics as the old store TTL).

package/src/handlers/internal/utils.ts

@@ -3,6 +3,8 @@ import { KeyAuthorization, Transaction as core_Transaction, TxEnvelopeTempo } fr
 import { type Client, BaseError } from 'viem'
 import * as z from 'zod/mini'
 
+import * as ApiResponse from '../../internal/Response.js'
+
 export function resolveChainId(value: unknown) {
   if (typeof value === 'number') return value
   if (typeof value === 'bigint') return Number(value)
@@ -97,24 +99,38 @@ export function rpcErrorJson(request: RpcRequest.RpcRequest, error: unknown) {
       { request },
     )
 
-  if ((error as { name?: string | undefined }).name === 'ZodError')
+  if (error instanceof z.core.$ZodError)
     return RpcResponse.from(
       {
         error: {
           code: RpcResponse.InvalidParamsError.code,
-          message: (error as Error).message,
+          data: {
+            code: 'invalid_params',
+            issues: ApiResponse.validationDetails(error.issues.slice(0, 10)),
+          },
+          message: 'Invalid params.',
         },
       },
       { request },
     )
 
   const inner = resolveError(error)
-  const message = inner.message ?? (error as Error).message
-  const code = inner.code ?? -32603
-  const data = inner.data
+  if (inner.code === undefined || inner.message === undefined)
+    return RpcResponse.from(
+      {
+        error: {
+          code: RpcResponse.InternalError.code,
+          data: { code: 'internal_error' },
+          message: 'Internal error',
+        },
+      },
+      { request },
+    )
+
+  const { code, data, message } = inner
   return RpcResponse.from(
     {
-      error: { code, message, ...(data ? { data } : {}) },
+      error: { code, message, ...(data === undefined ? {} : { data }) },
     },
     { request },
   )

package/src/handlers/relay.errors.test.ts

@@ -0,0 +1,153 @@
+import * as z from 'zod/mini'
+
+import * as Relay from '../../test/Relay.js'
+
+describe('request errors', () => {
+  test('returns Parse error for invalid JSON', async () => {
+    const server = await Relay.createServer((await Relay.relay()).listener)
+
+    try {
+      const response = await fetch(server.url, {
+        body: '{',
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32700,
+            "message": "Parse error",
+          },
+          "id": null,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test.each([
+    ['non-object request', 'null'],
+    ['invalid version', JSON.stringify({ id: 1, jsonrpc: '1.0', method: 'eth_chainId' })],
+    ['empty batch', '[]'],
+  ])('returns Invalid Request for %s', async (_name, body) => {
+    const server = await Relay.createServer((await Relay.relay()).listener)
+
+    try {
+      const response = await fetch(server.url, {
+        body,
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32600,
+            "message": "Invalid Request",
+          },
+          "id": null,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('returns one Invalid Request error for a malformed batch member', async () => {
+    const server = await Relay.createServer(
+      (
+        await Relay.relay({
+          getClient: () => {
+            throw new Error('transport credential must not leak')
+          },
+        })
+      ).listener,
+    )
+
+    try {
+      const response = await fetch(server.url, {
+        body: JSON.stringify([
+          { id: 1, jsonrpc: '2.0', method: 'eth_chainId' },
+          { id: 2, jsonrpc: '1.0', method: 'eth_chainId' },
+        ]),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        [
+          {
+            "error": {
+              "code": -32603,
+              "data": {
+                "code": "internal_error",
+              },
+              "message": "Internal error",
+            },
+            "id": 1,
+            "jsonrpc": "2.0",
+          },
+          {
+            "error": {
+              "code": -32600,
+              "message": "Invalid Request",
+            },
+            "id": null,
+            "jsonrpc": "2.0",
+          },
+        ]
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('returns bounded structured issues for invalid params', async () => {
+    const schema = z.object({ value: z.string() })
+    const server = await Relay.createServer(
+      (
+        await Relay.relay({
+          onRequest: async () => {
+            schema.parse({ value: 1 })
+          },
+        })
+      ).listener,
+    )
+
+    try {
+      const response = await fetch(server.url, {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32602,
+            "data": {
+              "code": "invalid_params",
+              "issues": [
+                {
+                  "message": "Invalid input",
+                  "path": [
+                    "value",
+                  ],
+                },
+              ],
+            },
+            "message": "Invalid params.",
+          },
+          "id": 1,
+          "jsonrpc": "2.0",
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+})