tapimo 0.0.1 → 0.1.0

package/src/apps/balances.test.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 import { Value as core_Value } from 'ox'
 
 import * as TestApp from '../../test/App.js'
@@ -12,9 +12,10 @@ import * as Tokens from './tokens.js'
 // verified tokens the bundle used to provide; a test can still override
 // `verifiedTokens`.
 const runtime = Runtime.get()
-const verified = TestApp.verifiedStore(runtime.chainId)
+const db = TestApp.database()
+await TestApp.verifiedSeed(db, runtime.chainId)
 function app(options: TestApp.create.Options = {}) {
-  return TestApp.client({ verifiedTokens: { store: verified }, ...options })
+  return TestApp.client({ db, ...options })
 }
 
 async function holderWithBalance(client: ReturnType<typeof app>) {

package/src/apps/blocks.test.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 import { Hex } from 'ox'
 import { zeroHash } from 'viem'
 

package/src/apps/coingecko.ts

@@ -1048,7 +1048,7 @@ async function loadDexBalances(
               account: dexAccount,
               token: token as ViemAddress,
             })
-            balances.set(token, balance)
+            balances.set(token, balance.amount)
           } catch {
             failed = true
             balances.set(token, 0n)

package/src/apps/exchanges.test.ts

@@ -1,5 +1,5 @@
 import type * as z from 'zod/mini'
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 
 import * as TestApp from '../../test/App.js'
 import * as Exchanges from './exchanges.js'

package/src/apps/indexer.test.ts

@@ -1,4 +1,4 @@
-import { RateLimit, Store } from 'cadent'
+import { RateLimit, Store } from 'tapimo'
 import * as TestApp from '../../test/App.js'
 import * as Mppx from '../../test/Mppx.js'
 import * as Runtime from '../../test/runtime.js'
@@ -117,7 +117,7 @@ describe('GET /indexer/query', () => {
           getClient: () => Tempo.client,
           recipient: Tempo.accounts[2].address,
         },
-        secretKey: 'secret_test_key',
+        secretKey: 'secret_test_key_0123456789abcdef',
       },
     })
     await exhaustQuota(RateLimit.memory({ store: rateLimitStore }), 'public:anonymous', {

package/src/apps/receipts.test.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 import { Hex } from 'ox'
 import { zeroHash } from 'viem'
 

package/src/apps/rpc.test.ts

@@ -227,16 +227,14 @@ describe('POST /rpc', () => {
     try {
       const app = TestApp.create({
         auth: {
-          source: TestApp.source({
-            keys: [
-              {
-                id: 'key_indexer_only',
-                orgId: 'org_test',
-                scopes: ['indexer:query'],
-                token: 'secret_indexer_key',
-              },
-            ],
-          }),
+          keys: [
+            {
+              id: 'key_indexer_only',
+              orgId: 'org_test',
+              scopes: ['indexer:query'],
+              token: 'secret_indexer_key',
+            },
+          ],
         },
       })
       const response = await app.fetch(
@@ -266,6 +264,98 @@ describe('POST /rpc', () => {
   })
 })
 
+describe('POST /rpc/relay', () => {
+  test('rejects anonymous callers', async () => {
+    const app = TestApp.create()
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/relay', {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        method: 'POST',
+      }),
+    )
+    const body = (await response.json()) as Record<string, unknown>
+    const { requestId, ...stable } = body
+
+    expect(response.status).toMatchInlineSnapshot(`401`)
+    expect(typeof requestId).toMatchInlineSnapshot(`"string"`)
+    expect(stable).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": "api_key_missing",
+          "message": "Missing API key",
+        },
+      }
+    `)
+  })
+
+  test('rejects keys missing the relay scope', async () => {
+    // The shared test key holds the data/indexer scopes only.
+    const app = TestApp.create()
+
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/rpc/relay', {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        headers: { 'tempo-api-key': TestApp.key.token },
+        method: 'POST',
+      }),
+    )
+    const body = (await response.json()) as Record<string, unknown>
+    const { requestId, ...stable } = body
+
+    expect(response.status).toMatchInlineSnapshot(`403`)
+    expect(typeof requestId).toMatchInlineSnapshot(`"string"`)
+    expect(stable).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": "api_key_forbidden",
+          "message": "API key missing required scope",
+        },
+      }
+    `)
+  })
+
+  test('proxies for keys holding rpc-relay', async () => {
+    const fetch = mockRpc()
+
+    try {
+      const app = TestApp.create({
+        auth: {
+          keys: [
+            {
+              id: 'key_relay',
+              orgId: 'org_test',
+              scopes: ['rpc-relay'],
+              token: 'secret_relay_key',
+            },
+          ],
+        },
+        rpc: { url: () => 'https://internal.rpc.test/json-rpc' },
+      })
+
+      const response = await app.fetch(
+        new Request('http://tempo-api.test/rpc/relay', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+          headers: { 'tempo-api-key': 'secret_relay_key' },
+          method: 'POST',
+        }),
+      )
+
+      expect(response.status).toMatchInlineSnapshot(`200`)
+      expect(await response.json()).toMatchInlineSnapshot(`
+        {
+          "id": 1,
+          "jsonrpc": "2.0",
+          "result": "0xa5bf",
+        }
+      `)
+      expect(fetch.calls[0]?.url).toMatchInlineSnapshot(`"https://internal.rpc.test/json-rpc"`)
+    } finally {
+      fetch.restore()
+    }
+  })
+})
+
 function mockRpc() {
   const original = globalThis.fetch
   const calls: {

package/src/apps/tokenlist.test.ts

@@ -1,5 +1,3 @@
-import { Store } from 'cadent'
-
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'
 import * as VerifiedTokens from '../internal/VerifiedTokens.js'
@@ -11,7 +9,7 @@ const reader = {
   orgId: 'org_test',
   scopes: ['data:read'],
   token: 'secret_reader',
-} satisfies TestApp.source.Key
+} satisfies TestApp.kvStore.Key
 
 /** A known list published into the store before exercising the read endpoint. */
 const seedList = [
@@ -27,11 +25,11 @@ function as(key: { token: string }) {
 
 /** Client whose verified-token store holds a published {@link seedList} snapshot. */
 async function seeded() {
-  const store = Store.memory()
-  await VerifiedTokens.replace(store, chainId, seedList)
+  const db = TestApp.database()
+  await VerifiedTokens.replace(db, chainId, seedList)
   return TestApp.client({
-    auth: { source: TestApp.source({ keys: [reader] }) },
-    verifiedTokens: { store },
+    auth: { keys: [reader] },
+    db,
   })
 }
 

package/src/apps/tokens.test.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'
@@ -10,9 +10,10 @@ import * as Tokens from './tokens.js'
 // verified tokens the bundle used to provide; a test can still override
 // `verifiedTokens`.
 const runtime = Runtime.get()
-const verified = TestApp.verifiedStore(runtime.chainId)
+const db = TestApp.database()
+await TestApp.verifiedSeed(db, runtime.chainId)
 function app(options: TestApp.create.Options = {}) {
-  return TestApp.client({ verifiedTokens: { store: verified }, ...options })
+  return TestApp.client({ db, ...options })
 }
 
 const verifiedTokenCount = 6

package/src/apps/transactions.test.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 import { Hex } from 'ox'
 import { zeroHash } from 'viem'
 

package/src/apps/transfers.test.ts

@@ -1,5 +1,5 @@
 import type * as z from 'zod/mini'
-import { Schema } from 'cadent'
+import { Schema } from 'tapimo'
 
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'

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

@@ -1,22 +1,15 @@
-import { Store } from 'cadent'
-
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'
 import * as VerifiedTokens from '../internal/VerifiedTokens.js'
 import * as Verified from './verified-tokens.js'
 
-// Mutations live in the admin API (`cadent/admin`) and are covered in
-// `../admin/apps/verified-tokens.test.ts`; these tests cover the public reads,
-// seeded by publishing a snapshot through the same core module the admin
-// writes use.
-
 /** Reader key for the data routes. */
 const reader = {
   id: 'key_reader',
   orgId: 'org_test',
   scopes: ['data:read'],
   token: 'secret_reader',
-} satisfies TestApp.source.Key
+} satisfies TestApp.kvStore.Key
 
 /** An address not present in the seed list. */
 const unknownAddress = '0x20c00000000000000000000000000000000000ff'
@@ -36,11 +29,11 @@ function as(key: { token: string }) {
 
 /** Client whose verified-token store holds a published {@link seedList} snapshot. */
 async function seeded() {
-  const store = Store.memory()
-  await VerifiedTokens.replace(store, chainId, seedList)
+  const db = TestApp.database()
+  await VerifiedTokens.replace(db, chainId, seedList)
   return TestApp.client({
-    auth: { source: TestApp.source({ keys: [reader] }) },
-    verifiedTokens: { store },
+    auth: { keys: [reader] },
+    db,
   })
 }
 
@@ -55,6 +48,25 @@ describe('GET /verified-tokens', () => {
     expect(body.data[1]?.logoUri).toBeUndefined()
   })
 
+  test('reads through `db.cached` when configured', async () => {
+    // Seed only the cached source: the list serving from it proves the
+    // snapshot path resolves `cached`, not `source`. `refreshMs: 0` forces a
+    // head check against this app's database (the per-isolate snapshot cell
+    // is keyed by chain id, so a prior test's cell could otherwise satisfy
+    // the read).
+    const cached = TestApp.database()
+    await VerifiedTokens.replace(cached, chainId, seedList)
+    const client = TestApp.client({
+      auth: { keys: [reader] },
+      db: { cached, source: TestApp.database() },
+      verifiedTokens: { refreshMs: 0 },
+    })
+    const response = await client.v1['verified-tokens'].$get({ query: {} }, as(reader))
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Verified.schema.listVerifiedTokens.Response)
+    expect(body.data.map((token) => token.address)).toEqual(seedList.map((token) => token.address))
+  })
+
   test('filters by currency (case-insensitive)', async () => {
     const response = await (
       await seeded()