tapimo 0.14.0 → 0.15.1

package/src/apps/mcp.ts

@@ -10,15 +10,18 @@ import * as Metadata from './metadata.js'
 /** Required document tag group whose operations surface as MCP tools. */
 const dataTagGroup = 'Data API'
 
-/** Optional document tag group added when the funding app is mounted. */
-const fundingTagGroup = 'Funding & Bridge API'
+/** Optional document tag group added when the routes app is mounted. */
+const routesTagGroup = 'Routes API'
 
 /** Tags inside the group hidden from MCP: partner-shaped CoinGecko mirrors and the MCP endpoint itself. */
 const excludedTags = ['CoinGecko', 'MCP']
 
+/** Internal header carrying the trusted caller identity through incur's generated request. */
+const clientIpHeader = 'tempo-mcp-client-ip'
+
 /** Usage guidance surfaced to MCP clients on initialize. */
 const instructions =
-  "Tempo MCP provides access to the Tempo API's data and inbound funding domains, plus documentation. Authenticated tools accept a Tempo API key sent as an `Authorization: Bearer` header on the HTTP request. List endpoints paginate via `cursor`/`nextCursor`. `docs_*` tools search the Tempo documentation."
+  "Tempo MCP provides access to the Tempo API's data and Routes domains, plus documentation. Authenticated tools accept a Tempo API key sent as an `Authorization: Bearer` header on the HTTP request. List endpoints paginate via `cursor`/`nextCursor`. `docs_*` tools search the Tempo documentation."
 
 /** Zod schemas owned by the MCP endpoint's OpenAPI description. */
 export namespace schema {
@@ -59,7 +62,7 @@ export namespace schema {
 
 /**
  * The MCP route group: a stateless streamable-HTTP MCP server at `/mcp` whose
- * tools mirror the API's data domain and its optional inbound funding domain,
+ * tools mirror the API's data domain and its optional Routes domain,
  * plus the remote Tempo docs tools. Mount alongside the other route groups:
  *
  * ```ts
@@ -106,7 +109,11 @@ export function mcp(options: mcp.Options) {
       // them onto the caller origin and dispatch in-process.
       fetch: (request) => {
         const url = new URL(request.url)
-        return fetch(new Request(new URL(url.pathname + url.search, origin), request))
+        const address = request.headers.get(clientIpHeader)
+        const forwarded = new Request(new URL(url.pathname + url.search, origin), request)
+        forwarded.headers.delete(clientIpHeader)
+        if (address) Auth.trustClientIp(forwarded, address)
+        return fetch(forwarded)
       },
       mcp: { instructions, title },
       openapi: scope(document),
@@ -115,7 +122,7 @@ export function mcp(options: mcp.Options) {
       // forwarded `Authorization` header).
       openapiConfig: {
         compact: true,
-        forwardHeaders: ['authorization'],
+        forwardHeaders: ['authorization', clientIpHeader],
         mode: 'namespace',
         security: false,
       },
@@ -130,7 +137,12 @@ export function mcp(options: mcp.Options) {
     const cli = await resolve(new URL(c.req.url).origin)
     // incur routes on the first path segment; pin the path to `/mcp` so a
     // mount prefix never leaks into its router.
-    return cli.fetch(new Request(new URL('/mcp', c.req.url), c.req.raw))
+    const request = new Request(new URL('/mcp', c.req.url), c.req.raw)
+    // Replace caller input with the identity resolved by the outer auth boundary.
+    request.headers.delete(clientIpHeader)
+    const address = Auth.getTrustedClientIp(c)
+    if (address) request.headers.set(clientIpHeader, address)
+    return cli.fetch(request)
   }
 
   // The documented POST carries the auth policy (described routes are
@@ -226,16 +238,16 @@ type Document = Openapi.OpenAPISpec & {
 const methods: readonly string[] = ['delete', 'get', 'head', 'options', 'patch', 'post', 'put', 'trace'] // prettier-ignore
 
 /**
- * Narrows the document to the data and optional inbound funding domains.
+ * Narrows the document to the data and optional Routes domains.
  * Management, relay, and session operations never surface as tools.
  */
 function scope(document: Document): Openapi.OpenAPISpec {
   const groups = document['x-tagGroups'] ?? []
   const dataGroup = groups.find((entry) => entry.name === dataTagGroup)
   if (!dataGroup) throw new Error(`openapi.json is missing the "${dataTagGroup}" tag group`)
-  const fundingGroup = groups.find((entry) => entry.name === fundingTagGroup)
+  const routesGroup = groups.find((entry) => entry.name === routesTagGroup)
   const tags = new Set(
-    [...dataGroup.tags, ...(fundingGroup?.tags ?? [])].filter((tag) => !excludedTags.includes(tag)),
+    [...dataGroup.tags, ...(routesGroup?.tags ?? [])].filter((tag) => !excludedTags.includes(tag)),
   )
   const paths: Document['paths'] = {}
   for (const [path, item] of Object.entries(document.paths)) {

package/src/apps/mpp/App.ts

@@ -2,6 +2,7 @@ import { Hono, type Context } from 'hono'
 import type * as z from 'zod/mini'
 
 import type * as App from '../../App.js'
+import * as Scope from '../../Scope.js'
 import * as Db from '../../db/Db.js'
 import * as Auth from '../../internal/Auth.js'
 import * as OpenApi from '../../internal/OpenApi.js'
@@ -25,7 +26,7 @@ export function mpp(options: mpp.Options) {
       OpenApi.validate('json', Mpp.schema.RelayInput, bodyValidation),
       OpenApi.describeRoute({
         description:
-          'Checks whether a completed MPP credential can be processed without submitting payment.\n\nTempo validates the challenge and credential, confirms the chain is supported, and screens the payment parties. It does not settle, broadcast, reserve funds, or consume the credential.\n\nRequires `mpp:write`. Well-formed requests return HTTP `200`; inspect `success`. Invalid bodies return `400`; missing or unauthorized API keys return `401` or `403`.',
+          'Checks whether a completed MPP credential can be processed without submitting payment.\n\nTempo validates the challenge and credential, confirms the chain is supported, and screens the payment parties. It does not settle, broadcast, reserve funds, or consume the credential.\n\nRequires `mpp:write` and, for Zones, `zone:<chainId>:read` or `zone:<chainId>:write`. Well-formed requests return HTTP `200`; inspect `success`. Invalid bodies return `400`; missing or unauthorized API keys return `401` or `403`.',
         operationId: 'validateMppCredential',
         responses: responses({
           description: 'The MPP credential validation result.',
@@ -52,7 +53,7 @@ export function mpp(options: mpp.Options) {
       OpenApi.validate('json', Mpp.schema.RelayInput, bodyValidation),
       OpenApi.describeRoute({
         description:
-          'Validates, screens, and submits a completed MPP credential to Tempo.\n\nRequires `mpp:write`. Well-formed requests return HTTP `200`; inspect `success`.\n\nUse `Idempotency-Key` on retries to replay a successful receipt. Reusing a key for a different credential returns `invalid_payment`, and in-flight duplicates return `temporarily_unavailable`.',
+          'Validates, screens, and submits a completed MPP credential to Tempo.\n\nRequires `mpp:write` and, for Zones, `zone:<chainId>:write`. Well-formed requests return HTTP `200`; inspect `success`.\n\nUse `Idempotency-Key` on retries to replay a successful receipt. Reusing a key for a different credential returns `invalid_payment`, and in-flight duplicates return `temporarily_unavailable`.',
         operationId: 'broadcastMppCredential',
         parameters: [
           {
@@ -149,8 +150,24 @@ async function authorizeBroadcast(
 ) {
   const { input, options: options_mpp } = options
   const chainId = Policy.chainId(input) ?? c.get('chainId')
+  const principal = Auth.getPrincipal(c) ?? undefined
   try {
-    Policy.assertSupportedChain({ chainId, supportedChainIds: c.get('supportedChainIds') })
+    Policy.assertChainAccess({
+      chainId,
+      principal,
+      supportedChainIds: c.get('supportedChainIds'),
+      zones: c.get('zones'),
+    })
+    // Validation can read Zone state, but submitting a credential requires broadcast access.
+    const scopes = principal?.type === 'api_key' ? principal.apiKey.scopes : undefined
+    if (
+      c.get('zones').has(chainId) &&
+      !scopes?.includes(Scope.wildcard) &&
+      !scopes?.includes(`zone:${chainId}:write`)
+    )
+      throw new Policy.PolicyDeniedError(
+        `Broadcasting to zone ${chainId} requires \`zone:${chainId}:write\`.`,
+      )
     return {
       chainId,
       feePayer: await Timing.time(c, 'mpp_fee_payer', () =>
@@ -159,7 +176,8 @@ async function authorizeBroadcast(
           db: Db.get(c.get('db')),
           feePayer: options_mpp.feePayer,
           input,
-          principal: Auth.getPrincipal(c) ?? undefined,
+          principal,
+          zones: c.get('zones'),
         }),
       ),
       type: 'authorized' as const,
@@ -266,17 +284,28 @@ function createAdapter(c: Context<App.Environment>, options: createAdapter.Optio
               principal,
               serializedTransaction,
               txFeeLimit: Billing.toBaseUnits(options_mpp.txFeeLimit ?? '1.00'),
+              zones: c.get('zones'),
             }),
         })
       : undefined
+  const storeKeyPrefix = (() => {
+    if (principal?.type === 'api_key') return `mpp:${principal.environment}:${principal.orgId}:`
+    if (principal?.type === 'super_admin') return 'mpp:super_admin:'
+    throw new Error('MPP relay requires an API key.')
+  })()
   return Adapter.create({
     chainId,
     ...(feePayer ? { feePayer } : {}),
-    getClient: (chainId) => {
-      const resolved = chainId ?? c.get('chainId')
-      Policy.assertSupportedChain({
+    getClient: (chainId_client) => {
+      const resolved = chainId_client ?? chainId
+      // Bind library-selected clients to the chain authorized for this credential.
+      if (resolved !== chainId)
+        throw new Policy.PolicyDeniedError('Credential chain does not match the authorized chain.')
+      Policy.assertChainAccess({
         chainId: resolved,
+        principal: principal ?? undefined,
         supportedChainIds: c.get('supportedChainIds'),
+        zones: c.get('zones'),
       })
       return c.get('getClient')(resolved)
     },
@@ -286,6 +315,7 @@ function createAdapter(c: Context<App.Environment>, options: createAdapter.Optio
       ? {}
       : { reportUnknown: options_mpp.reportUnknown }),
     state: options_mpp.state,
+    storeKeyPrefix,
     time: (name, fn) => Timing.time(c, name, fn),
   })
 }

package/src/apps/mpp/Mpp.test.ts

@@ -30,6 +30,13 @@ const organizationKey = {
   token: 'secret_mpp_org',
 } satisfies TestApp.kvStore.Key
 
+const otherOrganizationKey = {
+  id: 'key_mpp_other_org',
+  orgId: 'org_other',
+  scopes: ['mpp:write'],
+  token: 'secret_mpp_other_org',
+} satisfies TestApp.kvStore.Key
+
 const sandboxKey = {
   ...key,
   environment: 'sandbox',
@@ -38,6 +45,7 @@ const sandboxKey = {
 } satisfies TestApp.kvStore.Key
 
 const idempotencyKey = 'mpp_broadcast_01j3j1k2l3m4n5p6q7r8s9t0u'
+const superAdminSecret = 'secret_mpp_super_admin'
 
 const modes = ['pull', 'push'] as const
 
@@ -91,6 +99,16 @@ describe('MPP relay', () => {
     expect(await response.json()).toEqual({ success: true })
   })
 
+  test('verifies a valid Tempo credential for the super admin', async () => {
+    const app = TestApp.create({ auth: { keys: [], superAdmin: { secret: superAdminSecret } } })
+    const response = await post(app, '/v1/mpp/validate', await credential(), {
+      apiKey: superAdminSecret,
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ success: true })
+  })
+
   test('verifies a zero-amount proof credential', async () => {
     const app = TestApp.create({ auth: { keys: [key] } })
     const input = await credential({ amount: '0' })
@@ -224,6 +242,7 @@ describe('MPP relay', () => {
       },
       screeningStore: Store.memory(),
       state: Store.memory(),
+      storeKeyPrefix: 'test:',
     })
 
     await expect(
@@ -254,6 +273,7 @@ describe('MPP relay', () => {
       },
       screeningStore: Store.memory(),
       state: Store.memory(),
+      storeKeyPrefix: 'test:',
     })
 
     await expect(
@@ -278,6 +298,7 @@ describe('MPP relay', () => {
       },
       screeningStore: Store.memory(),
       state: Store.memory(),
+      storeKeyPrefix: 'test:',
     })
 
     await expect(adapter.verify(await credential())).resolves.toEqual({
@@ -316,6 +337,29 @@ describe('MPP relay', () => {
     )
   })
 
+  test('isolates payment replay protection between organizations', async () => {
+    const app = TestApp.create({
+      auth: { keys: [key, organizationKey, otherOrganizationKey] },
+      mpp: { state: Store.memory() },
+    })
+    const input = await credential({ mode: 'push', supportedModes: ['push'] })
+    const first = Mpp.schema.BroadcastResponse.parse(
+      await (await post(app, '/v1/mpp/broadcast', input)).json(),
+    )
+    const sameOrganization = Mpp.schema.BroadcastResponse.parse(
+      await (await post(app, '/v1/mpp/broadcast', input, { apiKey: organizationKey.token })).json(),
+    )
+    const otherOrganization = Mpp.schema.BroadcastResponse.parse(
+      await (
+        await post(app, '/v1/mpp/broadcast', input, { apiKey: otherOrganizationKey.token })
+      ).json(),
+    )
+
+    expect(first.success).toBe(true)
+    expect(sameOrganization.success).toBe(false)
+    expect(otherOrganization.success).toBe(true)
+  })
+
   test('returns a retryable result while the idempotent broadcast is pending', async () => {
     const state = TestApp.kvStore({ keys: [key] })
     const claim = await Idempotency.claim({
@@ -400,13 +444,10 @@ describe('MPP relay', () => {
 
     expect(payloadType(input)).toBe('transaction')
     expect(input.challenge.request['methodDetails']).toMatchObject({ feePayer: true })
-    expect(
-      Mpp.schema.BroadcastResponse.parse(
-        await (
-          await post(app, '/v1/mpp/broadcast', input, { apiKey: organizationKey.token })
-        ).json(),
-      ).success,
-    ).toBe(true)
+    const response = Mpp.schema.BroadcastResponse.parse(
+      await (await post(app, '/v1/mpp/broadcast', input, { apiKey: organizationKey.token })).json(),
+    )
+    expect(response.success, response.success ? undefined : response.error.message).toBe(true)
     expect(await SponsoredTransactions.listPending(db)).toMatchObject([
       {
         apiKeyId: organizationKey.id,
@@ -545,7 +586,7 @@ describe('MPP relay', () => {
     expect(await response.json()).toEqual({
       error: {
         code: Mpp.relayErrorCode.policyDenied,
-        message: 'Mainnet fee sponsorship requires a production API key.',
+        message: 'Sandbox API keys only support testnet. Use a testnet challenge.',
       },
       success: false,
     })

package/src/apps/mpp/Mpp.zone.test.ts

@@ -0,0 +1,219 @@
+import * as Mppx from 'mppx'
+import { Mppx as MppxClient, tempo as tempoClient } from 'mppx/client'
+import { Mppx as MppxServer, tempo as tempoServer } from 'mppx/server'
+
+import * as TestApp from '../../../test/App.js'
+import * as Runtime from '../../../test/runtime.js'
+import * as Tempo from '../../../test/Tempo.js'
+import type * as Log from '../../internal/Log.js'
+import * as Store from '../../internal/Store.js'
+import * as Viem from '../../internal/Viem.js'
+import * as Mpp from './Mpp.js'
+
+const runtime = Runtime.get()
+const zone = TestApp.zone({
+  chainId: runtime.zone.chainId,
+  rpcUrl: runtime.zone.internalRpcUrl,
+})
+const key = {
+  environment: 'production',
+  id: 'key_mpp_zone',
+  orgId: 'org_mpp_zone',
+  scopes: ['mpp:write'],
+  token: 'secret_mpp_zone',
+} satisfies TestApp.kvStore.Key
+const input = {
+  challenge: {
+    expires: new Date(Date.now() + 3_600_000).toISOString(),
+    id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0u',
+    intent: 'charge',
+    method: 'tempo',
+    realm: 'merchant.example',
+    request: {
+      amount: '1',
+      currency: Tempo.currency,
+      methodDetails: { chainId: zone.id, feePayer: true },
+      recipient: Tempo.accounts[0].address,
+    },
+  },
+  payload: { signature: `0x${'aa'.repeat(65)}`, type: 'transaction' },
+} satisfies Mpp.RelayInput
+
+describe('MPP Zone authorization', () => {
+  test.each(['validate', 'broadcast'] as const)(
+    '%s refuses unscoped challenge chains before resolving RPC',
+    async (operation) => {
+      const resolutions: number[] = []
+      const entries: Log.Entry[] = []
+      for (const scopes of [['mpp:write'], ['mpp:write', `zone:${zone.id + 1}:write`]]) {
+        const app = TestApp.create({
+          auth: { keys: [{ ...key, scopes }] },
+          defaultChainId: zone.id,
+          logger: (entry) => void entries.push(entry),
+          mpp: { feePayer: Tempo.accounts[2], state: Store.memory() },
+          rpc: ({ chainId }) => {
+            resolutions.push(chainId)
+            return { url: runtime.zone.internalRpcUrl }
+          },
+          zones: [zone],
+        })
+        for (const request of [
+          input.challenge.request,
+          { ...input.challenge.request, chainId: zone.id, methodDetails: { feePayer: true } },
+          { ...input.challenge.request, methodDetails: { feePayer: true } },
+        ]) {
+          const response = await post(app, operation, {
+            ...input,
+            challenge: { ...input.challenge, request },
+          })
+          expect(response.status).toBe(200)
+          expect(await response.json()).toEqual({
+            error: {
+              code: 'policy_denied',
+              message: `Chain id ${zone.id} is a zone. Use an API key granting \`zone:${zone.id}:read\` or \`zone:${zone.id}:write\`.`,
+            },
+            success: false,
+          })
+        }
+      }
+      expect(resolutions).toMatchInlineSnapshot(`[]`)
+      expect(entries).toHaveLength(6)
+      for (const entry of entries)
+        expect(entry.mpp).toMatchObject({ errorCode: 'policy_denied', outcome: 'failure' })
+    },
+  )
+
+  test.each(['validate', 'broadcast'] as const)(
+    '%s confines wildcard sandbox keys to testnet without requiring sponsorship',
+    async (operation) => {
+      const resolutions: number[] = []
+      const app = TestApp.create({
+        auth: { keys: [{ ...key, environment: 'sandbox', scopes: ['*'] }] },
+        rpc: ({ chainId }) => {
+          resolutions.push(chainId)
+          return { url: runtime.zone.internalRpcUrl }
+        },
+        zones: [{ ...zone, sourceId: Viem.chainId.mainnet }],
+      })
+      for (const chainId of [Viem.chainId.mainnet, zone.id]) {
+        const response = await post(app, operation, {
+          ...input,
+          challenge: {
+            ...input.challenge,
+            request: { ...input.challenge.request, methodDetails: { chainId, feePayer: false } },
+          },
+        })
+        expect(response.status).toBe(200)
+        expect(await response.json()).toMatchInlineSnapshot(`
+          {
+            "error": {
+              "code": "policy_denied",
+              "message": "Sandbox API keys only support testnet. Use a testnet challenge.",
+            },
+            "success": false,
+          }
+        `)
+      }
+      expect(resolutions).toMatchInlineSnapshot(`[]`)
+    },
+  )
+
+  test('requires active billing before mainnet Zone fee-payer access', async () => {
+    const resolutions: number[] = []
+    const app = TestApp.create({
+      auth: { keys: [{ ...key, scopes: ['mpp:write', `zone:${zone.id}:write`] }] },
+      mpp: { feePayer: Tempo.accounts[2], state: Store.memory() },
+      rpc: ({ chainId }) => {
+        resolutions.push(chainId)
+        return { url: runtime.zone.internalRpcUrl }
+      },
+      zones: [{ ...zone, sourceId: Viem.chainId.mainnet }],
+    })
+    expect(await (await post(app, 'broadcast', input)).json()).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": "policy_denied",
+          "message": "Active billing is required for mainnet fee sponsorship.",
+        },
+        "success": false,
+      }
+    `)
+    expect(resolutions).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('allows scoped validation but requires write scope to broadcast', async () => {
+    const input = await credential()
+    const app = TestApp.create({
+      auth: { keys: [{ ...key, scopes: ['mpp:write', `zone:${zone.id}:read`] }] },
+      zones: [zone],
+    })
+    expect(await (await post(app, 'validate', input)).json()).toMatchInlineSnapshot(`
+      {
+        "success": true,
+      }
+    `)
+    expect(await (await post(app, 'broadcast', input)).json()).toEqual({
+      error: {
+        code: 'policy_denied',
+        message: `Broadcasting to zone ${zone.id} requires \`zone:${zone.id}:write\`.`,
+      },
+      success: false,
+    })
+  })
+
+  test.each([
+    { environment: 'production', scopes: ['mpp:write', `zone:${zone.id}:write`], sourceId: 4217 },
+    { environment: 'production', scopes: ['*'], sourceId: 4217 },
+    { environment: 'sandbox', scopes: ['mpp:write', `zone:${zone.id}:write`], sourceId: 42431 },
+  ] as const)('allows authorized $environment Zone credentials with $scopes', async (options) => {
+    const input = await credential()
+    const app = TestApp.create({
+      auth: { keys: [{ ...key, environment: options.environment, scopes: [...options.scopes] }] },
+      zones: [{ ...zone, sourceId: options.sourceId }],
+    })
+    for (const operation of ['validate', 'broadcast'] as const)
+      expect(await (await post(app, operation, input)).json()).toMatchObject({ success: true })
+  })
+})
+
+async function credential(): Promise<Mpp.RelayInput> {
+  const client = Viem.getClient({ chainId: zone.id, zone })
+  const issuer = MppxServer.create({
+    methods: [
+      tempoServer.charge({
+        account: Tempo.accounts[0],
+        currency: Tempo.currency,
+        getClient: () => client,
+      }),
+    ],
+    realm: 'merchant.example',
+    secretKey: 'test-mpp-secret-key-for-payment-sessions',
+  })
+  const challenge = await issuer.challenge.tempo.charge({ amount: '0' })
+  const payer = MppxClient.create({
+    methods: [tempoClient({ account: Tempo.accounts[1], getClient: () => client })],
+    polyfill: false,
+  })
+  return Mppx.Credential.deserialize(
+    await payer.createCredential(
+      new Response(null, {
+        headers: { 'www-authenticate': Mppx.Challenge.serialize(challenge) },
+        status: 402,
+      }),
+    ),
+  )
+}
+
+function post(
+  app: ReturnType<typeof TestApp.create>,
+  operation: 'validate' | 'broadcast',
+  input: Mpp.RelayInput,
+) {
+  return app.fetch(
+    new Request(`http://tempo-api.test/v1/mpp/${operation}?chainId=42431`, {
+      body: JSON.stringify(input),
+      headers: { 'content-type': 'application/json', 'tempo-api-key': key.token },
+      method: 'POST',
+    }),
+  )
+}

package/src/apps/mpp/internal/Adapter.ts

@@ -1,12 +1,16 @@
 import * as Mppx from 'mppx'
 import { tempo } from 'mppx/server'
+import * as Hex from 'ox/Hex'
 import { maxUint256 } from 'viem'
+import { getBlock } from 'viem/actions'
 import type { LocalAccount } from 'viem/accounts'
+import { Transaction } from 'viem/tempo'
 
 import * as Store from '../../../internal/Store.js'
 import * as Viem from '../../../internal/Viem.js'
 import * as Mpp from '../Mpp.js'
 import * as MppError from './Error.js'
+import * as Policy from './Policy.js'
 import * as Screening from './Screening.js'
 import * as ScreenManager from './ScreenManager.js'
 import * as Utils from './Utils.js'
@@ -30,6 +34,7 @@ export function create(options: create.Options): Adapter {
     screeningStore,
     screeningTtl = Screening.defaultTtl,
     state,
+    storeKeyPrefix,
     time = (_, fn) => fn(),
   } = options
   const screenManager = ScreenManager.create({
@@ -55,6 +60,7 @@ export function create(options: create.Options): Adapter {
       getClient: ({ chainId: chainId_option }) =>
         getClient(chainId_option as Viem.ChainId | undefined),
       store: Utils.mppxStore(state),
+      storeKeyPrefix,
     }),
   ] as const
 
@@ -66,6 +72,31 @@ export function create(options: create.Options): Adapter {
     await time('mpp_screen', () => screenManager.screen(Utils.addresses(result)))
   }
 
+  async function assertFeeMarketAdmission(input: Mpp.RelayInput) {
+    if (!feePayer || !Policy.requiresFeePayer(input)) return
+    const payload =
+      input.payload && typeof input.payload === 'object' && !Array.isArray(input.payload)
+        ? (input.payload as Record<string, unknown>)
+        : undefined
+    if (
+      payload?.['type'] !== 'transaction' ||
+      typeof payload['signature'] !== 'string' ||
+      !Hex.validate(payload['signature'])
+    )
+      return
+    const transaction = Transaction.deserialize(payload['signature'] as Hex.Hex)
+    if (typeof transaction.maxFeePerGas !== 'bigint') return
+    const block = await getBlock(getClient(transaction.chainId as Viem.ChainId | undefined), {
+      blockTag: 'latest',
+      includeTransactions: false,
+    })
+    if (block.baseFeePerGas !== null)
+      Policy.assertFeeMarketAdmission({
+        baseFeePerGas: block.baseFeePerGas,
+        maxFeePerGas: transaction.maxFeePerGas,
+      })
+  }
+
   function failure(cause: unknown, operation: 'broadcast' | 'verify') {
     const error = MppError.map(cause)
     if (error.code === Mpp.relayErrorCode.unknown) reportUnknown?.({ operation })
@@ -76,6 +107,7 @@ export function create(options: create.Options): Adapter {
     async broadcast(input) {
       try {
         await validateOrThrow(input)
+        await assertFeeMarketAdmission(input)
         const result = await time('mpp_broadcast', () =>
           Mppx.Method.broadcastCredential(methods, credential(input)),
         )
@@ -130,6 +162,8 @@ export declare namespace create {
     screeningTtl?: number | undefined
     /** Durable state used for MPPX replay protection. */
     state: Store.State
+    /** Tenant namespace for MPPX replay-protection records. */
+    storeKeyPrefix: string
     /** Measures a named relay operation. */
     time?: (<value>(name: string, fn: () => Promise<value>) => Promise<value>) | undefined
   }