tapimo 0.7.1 → 0.8.0

package/src/apps/index.ts

@@ -1,5 +1,7 @@
-export { data, FundingQuoteProviders, FxOracle } from './data/index.js'
+export { data, FxOracle } from './data/index.js'
+export { funding } from './funding/index.js'
 export { management } from './management/index.js'
 export { mcp } from './mcp.js'
 export { mpp } from './mpp/index.js'
 export { relay } from './relay/index.js'
+export * as Zones from './Zones.js'

package/src/apps/management/Billing.test.ts

@@ -576,4 +576,33 @@ describe('createRequestUsageReporter', () => {
     expect((await RequestUsage.getBucket(db, { bucketStart, environment: 'production', orgId: 'org_1' }))?.reportedCount).toBe(6) // prettier-ignore
     await db.close()
   })
+
+  test('behavior: exposes the durable retry backlog for alerting', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    await StripeCustomers.setStatus(db, 'org_1', 'active')
+    const { stripe } = stubStripe({
+      meterEvent() {
+        throw new Error('Stripe unavailable')
+      },
+      subscriptions: [{ items: ['feePayerSpend', 'apiRequests'], status: 'active' }],
+    })
+    const reporter = Billing.createRequestUsageReporter({
+      db,
+      now: () => Date.now(),
+      readCounts: async () => [{ bucketStart, count: 4, orgId: 'org_1' }],
+      stripe,
+    })
+
+    expect(await reporter.tick()).toStrictEqual({ failed: 1, reported: 0, skipped: 0 })
+    expect(await reporter.pending()).toEqual([
+      {
+        count: 1,
+        environment: 'production',
+        oldestPendingAgeSeconds: expect.any(Number),
+      },
+    ])
+    await db.close()
+  })
 })

package/src/apps/management/Billing.ts

@@ -444,6 +444,20 @@ export function createRequestUsageReporter(
     ...(sandboxStripe ? [{ client: sandboxStripe, environment: 'sandbox' as const }] : []),
   ]
   return {
+    async pending() {
+      return Promise.all(
+        clients.map(async ({ environment }) => {
+          const status = await RequestUsage.getPendingStatus(Db.get(db), environment)
+          return {
+            count: status.count,
+            environment,
+            oldestPendingAgeSeconds: status.oldestAttemptedAt
+              ? Math.max(0, Math.floor((now() - new Date(status.oldestAttemptedAt).getTime()) / 1_000))
+              : 0,
+          }
+        }),
+      )
+    },
     async tick() {
       const database = Db.get(db)
       let failed = 0
@@ -583,9 +597,18 @@ export declare namespace createRequestUsageReporter {
 
   /** A scheduled request-metering job. */
   type Reporter = {
+    /** Reads the current retry backlog without sending meter events. */
+    pending(): Promise<readonly Pending[]>
     /** Runs one reporting pass across production (and sandbox when configured). */
     tick(): Promise<{ failed: number; reported: number; skipped: number }>
   }
+
+  /** Current durable retry backlog for one billing environment. */
+  type Pending = {
+    count: number
+    environment: StripeCustomers.Record['environment']
+    oldestPendingAgeSeconds: number
+  }
 }
 
 /** Composite key for the in-tick blocked-bucket set. */

package/src/apps/management/Error.ts

@@ -0,0 +1,12 @@
+import type { Context } from 'hono'
+
+import * as Response from '../../internal/Response.js'
+
+/** Returns the standard error for operations that require a user session. */
+export function sessionRequired(c: Context) {
+  return Response.error(c, {
+    code: 'forbidden',
+    message: 'Session required',
+    status: 403,
+  })
+}

package/src/apps/management/routes/api-keys.test.ts

@@ -119,9 +119,11 @@ describe('keys', () => {
 
     // Even the org owner cannot self-mint zone access: membership is
     // controlled zone-side, so zone scopes are super-admin-issued.
-    const denied = await app.request(base, json('POST', owner, { scopes: ['zone:421700001:read'] }))
-    expect(denied.status).toBe(403)
-    expect(await denied.json()).toMatchObject({ error: { code: 'scope_not_issuable' } })
+    for (const scope of ['zone:421700001:read', 'zone:421700001:write']) {
+      const denied = await app.request(base, json('POST', owner, { scopes: [scope] }))
+      expect(denied.status).toBe(403)
+      expect(await denied.json()).toMatchObject({ error: { code: 'scope_not_issuable' } })
+    }
   })
 
   test('restricts project management keys without delegating issuance', async () => {
@@ -254,6 +256,99 @@ describe('keys', () => {
     expect(empty).toEqual({ data: [] })
   })
 
+  test('creates, reads, updates, enforces, and clears an IP allowlist', async () => {
+    const state = TestApp.kvStore()
+    const app = TestApp.create({
+      // Avoid waiting for the accepted KV and isolate-cache propagation delay.
+      auth: { cache: false, superAdmin: { secret } },
+      kv: { store: state },
+      session: { wallet: { origin } },
+    }).get(
+      '/custom/allowlist-test',
+      Auth.policy({ apiKey: { scopes: ['data:read'] } }),
+      OpenApi.describeRoute({
+        operationId: 'getAllowlistTest',
+        responses: { 200: { description: 'Allowlist test response.' } },
+        summary: 'Test allowlist',
+      }),
+      (c) => c.json({ ok: true }, 200),
+    )
+    const cookie = await session(app)
+    const { org, project } = await fixture(app, cookie)
+    const base = `/v1/orgs/${org.id}/projects/${project.id}/api-keys`
+    const created = await TestApp.json(
+      await app.request(
+        base,
+        superAdminJson('POST', {
+          allowedIps: ['203.0.113.0/24'],
+          scopes: ['data:read'],
+        }),
+      ),
+      Keys.schema.createApiKey.Response,
+    )
+
+    expect(created.allowedIps).toEqual(['203.0.113.0/24'])
+    const authenticate = (address?: string) =>
+      app.request('/custom/allowlist-test', {
+        headers: {
+          ...(address ? { 'cf-connecting-ip': address } : {}),
+          'tempo-api-key': created.token,
+        },
+      })
+    const listed = await TestApp.json(
+      await app.request(base, { headers: { cookie } }),
+      Keys.schema.listApiKeys.Response,
+    )
+    expect(listed.data[0]?.allowedIps).toEqual(['203.0.113.0/24'])
+
+    expect((await authenticate('203.0.113.7')).status).toBe(200)
+    const denied = await authenticate('198.51.100.7')
+    expect(denied.status).toBe(403)
+    expect(await denied.json()).toMatchObject({ error: { code: 'api_key_ip_forbidden' } })
+
+    const updated = await TestApp.json(
+      await app.request(
+        `${base}/${created.id}`,
+        json('PATCH', cookie, { allowedIps: ['198.51.100.7'] }),
+      ),
+      Keys.schema.Key,
+    )
+    expect(updated.allowedIps).toEqual(['198.51.100.7'])
+
+    expect((await authenticate('203.0.113.7')).status).toBe(403)
+    expect((await authenticate('198.51.100.7')).status).toBe(200)
+
+    const cleared = await TestApp.json(
+      await app.request(`${base}/${created.id}`, json('PATCH', cookie, { allowedIps: [] })),
+      Keys.schema.Key,
+    )
+    expect(cleared.allowedIps).toEqual([])
+    expect((await authenticate()).status).toBe(200)
+  })
+
+  test('rejects malformed IP allowlists on create and update', async () => {
+    const app = createApp()
+    const cookie = await session(app)
+    const { org, project } = await fixture(app, cookie)
+    const base = `/v1/orgs/${org.id}/projects/${project.id}/api-keys`
+
+    const invalidCreate = await app.request(
+      base,
+      json('POST', cookie, { allowedIps: ['203.0.113.0/33'], scopes: ['data:read'] }),
+    )
+    expect(invalidCreate.status).toBe(400)
+
+    const created = await TestApp.json(
+      await app.request(base, json('POST', cookie, { scopes: ['data:read'] })),
+      Keys.schema.createApiKey.Response,
+    )
+    const invalidUpdate = await app.request(
+      `${base}/${created.id}`,
+      json('PATCH', cookie, { allowedIps: ['*'] }),
+    )
+    expect(invalidUpdate.status).toBe(400)
+  })
+
   test('rejects the wildcard scope at mint', async () => {
     const app = createApp()
     const cookie = await session(app)
@@ -425,6 +520,11 @@ describe('keys', () => {
       { headers: { cookie: owner }, method: 'DELETE' },
     )
     expect(crossRevoke.status).toBe(404)
+    const crossUpdate = await app.request(
+      `/v1/orgs/${org.id}/projects/${other.id}/api-keys/${minted.id}`,
+      json('PATCH', owner, { allowedIps: ['203.0.113.0/24'] }),
+    )
+    expect(crossUpdate.status).toBe(404)
 
     // Foreign session: the whole surface 404s at the org-ownership link.
     const stranger = await session(app)

package/src/apps/management/routes/api-keys.ts

@@ -3,6 +3,7 @@ import * as z from 'zod/mini'
 
 import * as Analytics from '../../../analytics/Analytics.js'
 import * as RequestEvents from '../../../analytics/tables/requestEvents.js'
+import * as ApiKey from '../../../ApiKey.js'
 import * as ApiKeys from '../../../ApiKeys.js'
 import type * as App from '../../../App.js'
 import * as Db from '../../../db/Db.js'
@@ -12,12 +13,19 @@ import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Scope from '../../../Scope.js'
+import * as ManagementError from '../Error.js'
 
 /** Zod schemas owned by the API-keys resource. */
 export namespace schema {
   /** One API key: metadata only — the token appears once, at mint. */
   export const Key = Schema.describe(
     z.object({
+      allowedIps: ApiKey.schema.AllowedIps.check(
+        z.describe(
+          'Client IP addresses and CIDR ranges allowed to use this key. An empty list means unrestricted.',
+        ),
+        z.meta({ examples: [['203.0.113.0/24', '2001:db8::1']] }),
+      ),
       createdAt: z
         .string()
         .check(
@@ -139,6 +147,14 @@ export namespace schema {
   /** Request body minting a key. The wildcard scope is not issuable here. */
   export const KeyBody = z
     .object({
+      allowedIps: z
+        .optional(ApiKey.schema.AllowedIps)
+        .check(
+          z.describe(
+            'Client IP addresses and CIDR ranges allowed to use the key. Omit or use an empty list for unrestricted access.',
+          ),
+          z.meta({ examples: [['203.0.113.0/24']] }),
+        ),
       environment: z
         ._default(z.enum(['production', 'sandbox']), 'production')
         .check(z.describe('Key environment.'), z.meta({ examples: ['sandbox'] })),
@@ -223,10 +239,25 @@ export namespace schema {
       })
       .check(z.describe('Confirmation that the key was revoked.'))
   }
+
+  /** Schemas for the updateApiKey operation. */
+  export namespace updateApiKey {
+    /** Request body replacing or clearing a key's IP allowlist. */
+    export const Body = z
+      .object({
+        allowedIps: ApiKey.schema.AllowedIps.check(
+          z.describe(
+            'Replacement client IP/CIDR allowlist. Use an empty list for unrestricted access.',
+          ),
+          z.meta({ examples: [['203.0.113.0/24']] }),
+        ),
+      })
+      .check(z.describe("Fields for updating an API key's network access."))
+  }
 }
 
 /**
- * Mounts project-attributed API key mint, list, and revoke routes plus the org-wide list. Project routes enforce caller organization and project attribution.
+ * Mounts project-attributed API key mint, list, update, and revoke routes plus the org-wide list. Project routes enforce caller organization and project attribution.
  */
 export function apiKeys(options: apiKeys.Options = {}) {
   const hidden = !options.enabled
@@ -281,7 +312,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
         const kv = c.get('kv')
         if (!kv) return notEnabled(c)
         const createdBy = mintedBy(c)
-        if (!createdBy) return sessionRequired(c)
+        if (!createdBy) return ManagementError.sessionRequired(c)
 
         const body = c.req.valid('json')
 
@@ -312,6 +343,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
             {
               createdBy,
               environment: body.environment,
+              ...(body.allowedIps === undefined ? {} : { allowedIps: body.allowedIps }),
               ...(billingActive === undefined ? {} : { billingActive }),
               ...(body.name === undefined ? {} : { name: body.name }),
               orgId,
@@ -452,6 +484,69 @@ export function apiKeys(options: apiKeys.Options = {}) {
         }
       },
     )
+    .patch(
+      '/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects/:projectId{prj_[A-Za-z0-9_-]+}/api-keys/:keyId{key_[A-Za-z0-9_-]+}',
+      Auth.policy({ apiKey: { scopes: ['management:write'] }, session: true }),
+      Auth.ensureOrg({ role: 'admin' }),
+      Auth.ensureProject(),
+      OpenApi.validate('param', schema.KeyParams, {
+        code: 'param_invalid',
+        message: 'Check the path parameters and try again.',
+      }),
+      OpenApi.validate('json', schema.updateApiKey.Body, {
+        code: 'body_invalid',
+        message: 'Check the request body and try again.',
+      }),
+      OpenApi.describeRoute({
+        description:
+          "Replace an API key's client IP/CIDR allowlist. An empty list removes the restriction.",
+        hide: hidden,
+        operationId: 'updateApiKey',
+        responses: OpenApi.responses({
+          errors: {
+            404: 'No accessible API key was found for this id.',
+          },
+          success: {
+            description: 'The updated API key metadata.',
+            schema: schema.Key,
+          },
+        }),
+        summary: 'Update API key',
+        tags: ['API Keys'],
+      }),
+      async (c) => {
+        if (Auth.narrowAccess) return Auth.accessError(c)
+        if (Auth.narrowScope) return Auth.ensureProjectError(c)
+        if (OpenApi.narrowValidation)
+          return OpenApi.validationError(c, {
+            code: 'param_invalid',
+            message: 'Check the path parameters and try again.',
+          })
+        if (OpenApi.narrowValidation)
+          return OpenApi.validationError(c, {
+            code: 'body_invalid',
+            message: 'Check the request body and try again.',
+          })
+
+        const kv = c.get('kv')
+        if (!kv) return notEnabled(c)
+        const { keyId } = c.req.valid('param')
+        try {
+          const record = await ApiKeys.get(kv.store, keyId, {
+            scopeCatalog: c.get('scopeCatalog'),
+          })
+          if (!record || record.orgId !== Auth.org(c).id || record.projectId !== Auth.project(c).id)
+            return keyNotFound(c)
+          const updated = await ApiKeys.update(kv.store, keyId, c.req.valid('json'), {
+            scopeCatalog: c.get('scopeCatalog'),
+          })
+          if (!updated) return keyNotFound(c)
+          return c.json(Response.validated(schema.Key, serializeKey(updated)), 200)
+        } catch (cause) {
+          return Response.upstream(c, cause)
+        }
+      },
+    )
     .delete(
       '/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/projects/:projectId{prj_[A-Za-z0-9_-]+}/api-keys/:keyId{key_[A-Za-z0-9_-]+}',
       Auth.policy({ apiKey: { scopes: ['management:write'] }, session: true }),
@@ -531,6 +626,7 @@ async function serializeKeys(c: Context<App.Environment>, records: readonly ApiK
 /** Projects a persisted record onto the management key shape (no rate limits, no token). */
 function serializeKey(record: ApiKeys.Record, lastUsedAt?: string) {
   return {
+    allowedIps: [...record.allowedIps],
     createdAt: record.createdAt,
     ...(record.createdBy === undefined ? {} : { createdBy: record.createdBy }),
     environment: record.environment,
@@ -582,11 +678,3 @@ function notEnabled(c: Context<App.Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<App.Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/invitations.ts

@@ -8,6 +8,7 @@ import * as Memberships from '../../../db/tables/memberships.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
+import * as ManagementError from '../Error.js'
 
 import type { Email, Environment } from '../App.js'
 
@@ -386,7 +387,7 @@ export function invitations() {
         if (Auth.narrowAccess) return Auth.superAdminAccessError(c)
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
         // Without a verified email there is nothing to match against.
         if (!principal.email)
           return c.json(Response.validated(schema.listMyInvitations.Response, { data: [] }), 200)
@@ -437,7 +438,7 @@ export function invitations() {
           })
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
 
         const { invitationId } = c.req.valid('param')
         const db = Db.get(c.get('db'))
@@ -492,7 +493,7 @@ export function invitations() {
           })
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
 
         const { invitationId } = c.req.valid('param')
         const db = Db.get(c.get('db'))
@@ -575,11 +576,3 @@ function invitationNotFound(c: Context<Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/orgs.ts

@@ -11,6 +11,7 @@ import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Organizations from '../../../db/tables/organizations.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
+import * as ManagementError from '../Error.js'
 
 /** Zod schemas owned by the organizations resource. */
 export namespace schema {
@@ -178,7 +179,7 @@ export function orgs() {
 
         const principal = Auth.getPrincipal(c)
         if (principal?.type !== 'session' && principal?.type !== 'super_admin')
-          return sessionRequired(c)
+          return ManagementError.sessionRequired(c)
 
         const body = c.req.valid('json')
         const db = Db.get(c.get('db'))
@@ -380,11 +381,3 @@ function organizationNotFound(c: Context<App.Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<App.Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/scopes.test.ts

@@ -14,10 +14,14 @@ describe('scopes', () => {
     expect(response.headers.get('cache-control')).toMatchInlineSnapshot(
       `"private, max-age=300, stale-while-revalidate=3600"`,
     )
-    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry].map((entry) => ({ ...entry })))
+    expect(body.data).toEqual(
+      [...Scope.catalog, Scope.zoneEntry, Scope.zoneWriteEntry].map((entry) => ({ ...entry })),
+    )
     expect(body.data.map((entry) => entry.scope)).toMatchInlineSnapshot(`
       [
         "data:read",
+        "funding:read",
+        "funding:write",
         "indexer:query",
         "management:read",
         "management:write",
@@ -27,6 +31,7 @@ describe('scopes', () => {
         "webhooks:read",
         "webhooks:write",
         "zone:<chainId>:read",
+        "zone:<chainId>:write",
       ]
     `)
   })
@@ -42,6 +47,6 @@ describe('scopes', () => {
     const body = await TestApp.json(response, Scopes.schema.getScopes.Response)
 
     expect(response.status).toBe(200)
-    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry, custom])
+    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry, Scope.zoneWriteEntry, custom])
   })
 })

package/src/apps/management/routes/scopes.ts

@@ -24,7 +24,7 @@ export namespace schema {
           .string()
           .check(
             z.describe(
-              'Scope identifier used in API-key grants and route policies. `zone:<chainId>:read` is a template: grants carry a concrete zone chain id.',
+              'Scope identifier used in API-key grants and route policies. Zone templates carry a concrete chain id and access level in grants.',
             ),
             z.meta({ examples: ['data:read'] }),
           ),
@@ -66,7 +66,7 @@ export function scopes() {
     }),
     Cache.response<App.Environment>({
       cacheControl: Cache.policies.stable,
-      name: 'tempo-api:scopes:v3',
+      name: 'tempo-api:scopes:v5',
       key: (c) => {
         const url = new URL(c.req.url)
         url.search = ''

package/src/apps/management/routes/webhooks.test.ts

@@ -2,6 +2,7 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 
 import * as App from '../../../App.js'
 import * as Memberships from '../../../db/tables/memberships.js'
+import * as Cursor from '../../../internal/Cursor.js'
 import * as core_Webhooks from '../../../internal/Webhooks.js'
 import * as TestApp from '../../../../test/App.js'
 import { management } from '../App.js'
@@ -47,7 +48,8 @@ async function organization(app: ReturnType<typeof createApp>, cookie: string) {
 
 describe('webhooks', () => {
   test('creates, lists, pauses, and deletes an organization webhook', async () => {
-    const app = createApp()
+    const db = TestApp.database()
+    const app = createApp({ db })
     const cookie = await session(app)
     const org = await organization(app, cookie)
     const collection = `/v1/orgs/${org.id}/webhooks`
@@ -65,6 +67,9 @@ describe('webhooks', () => {
     expect(createdResponse.status).toBe(200)
     const created = await TestApp.json(createdResponse, Webhooks.schema.createWebhook.Response)
     expect(created).toHaveProperty('secret', expect.stringMatching(/^whsec_/))
+    expect(Cursor.decode((await core_Webhooks.getCursor(db, created.id))!, ['int'])).toEqual([
+      expect.any(Number),
+    ])
 
     const listedResponse = await app.request(collection, { headers: { cookie } })
     expect(listedResponse.status).toBe(200)

package/src/apps/management/routes/webhooks.ts

@@ -6,6 +6,7 @@ import * as Db from '../../../db/Db.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
+import * as WebhookDestination from '../../../internal/WebhookDestination.js'
 import * as Webhooks from '../../../internal/Webhooks.js'
 import { schema as webhookSchema } from '../../data/routes/webhooks.js'
 import type { Environment } from '../App.js'
@@ -217,17 +218,28 @@ export function webhooks(options: webhooks.Options = {}) {
         if (!supportedChainIds.has(chainId))
           return Response.unsupportedChainId(c, chainId, supportedChainIds)
         try {
+          // Preserve destination errors before the creation-time RPC dependency.
+          WebhookDestination.assertDestination(body.destination)
+          const db = Db.get(c.get('db'))
+          const maxPerOwner = options.webhook.maxPerOwner ?? defaultMaxPerOwner
+          const owner_ = owner(Auth.org(c).id)
+          if ((await Webhooks.countSubscriptions(db, owner_)) >= maxPerOwner)
+            throw new Webhooks.LimitExceededError(maxPerOwner)
+          const startBlockNumber = Number(await c.get('getClient')(chainId).getBlockNumber())
           const subscription = await Webhooks.createSubscription(
-            Db.get(c.get('db')),
+            db,
             {
               chainId,
               ...(body.context === undefined ? {} : { context: body.context }),
               destination: body.destination,
               eventType: body.eventType,
               filters: body.filters,
-              owner: owner(Auth.org(c).id),
+              owner: owner_,
+            },
+            {
+              maxPerOwner,
+              startBlockNumber,
             },
-            { maxPerOwner: options.webhook.maxPerOwner ?? defaultMaxPerOwner },
           )
           return c.json(
             Response.validated(schema.createWebhook.Response, created(subscription)),

package/src/apps/mcp.test.ts

@@ -1,4 +1,6 @@
 import { Cli as incur_Cli, z } from 'incur'
+import { App } from 'tapimo'
+import { data } from 'tapimo/apps'
 
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'
@@ -17,7 +19,7 @@ const reader = {
 /** Composes a test app with the MCP group mounted, dispatching in-process. */
 function createHost(
   options: {
-    app?: ReturnType<typeof TestApp.create> | undefined
+    app?: Host | undefined
     docs?: mcp.Options['docs'] | undefined
   } = {},
 ) {
@@ -149,7 +151,7 @@ test('identifies as Tempo MCP', async () => {
   })
 })
 
-test('scopes tools to the data domain', async () => {
+test('scopes tools to the data and inbound funding domains', async () => {
   const { app, host } = createHost({ docs: docsStub() })
 
   // The domain filter must drop paths that actually exist in the spec.
@@ -170,6 +172,8 @@ test('scopes tools to the data domain', async () => {
   const tools = (await toolsSearch(host)).map((tool) => tool.name)
 
   expect(tools).toContain('v1_tokens_get')
+  expect(tools).toContain('v1_funding_quotes')
+  expect(tools).toContain('v1_funding_transfers_post')
   expect(tools).toContain('docs_search')
   // RPC is part of the data domain tag group.
   expect(tools.some((name) => name.startsWith('rpc'))).toBe(true)
@@ -180,6 +184,17 @@ test('scopes tools to the data domain', async () => {
   expect(tools.some((name) => name.startsWith('v1_me'))).toBe(false)
 })
 
+test('keeps the data tools functional when funding is omitted', async () => {
+  const app = App.create({ auth: false, db: TestApp.database() }).route('/', data())
+  const { host } = createHost({ app })
+
+  await initialize(host)
+  const tools = (await toolsSearch(host)).map((tool) => tool.name)
+
+  expect(tools).toContain('v1_tokens_get')
+  expect(tools.some((name) => name.startsWith('v1_funding_'))).toBe(false)
+})
+
 test('keeps tool input schemas compact', async () => {
   const { host } = createHost()
   await initialize(host)