tapimo 0.7.0 → 0.7.2

package/src/apps/mpp/Mpp.ts

@@ -1,8 +1,5 @@
-import type { Context, TypedResponse } from 'hono'
 import * as z from 'zod/mini'
 
-import type * as App from '../../App.js'
-import * as Response from '../../internal/Response.js'
 import * as Schema from '../../internal/Schema.js'
 
 /** Stable MPP relay failure codes. */
@@ -92,12 +89,6 @@ export type BroadcastResponse =
   | { receipt: Receipt; success: true }
   | { error: RelayError; success: false }
 
-/** Retryable response returned while relay settlement is disabled. */
-export type Unavailable = {
-  error: { code: 'temporarily_unavailable'; message: 'MPP relay is not enabled yet.' }
-  success: false
-}
-
 function errorCode<const code extends RelayErrorCode>(value: code, description: string) {
   return z.literal(value).check(z.describe(description), z.meta({ examples: [value] }))
 }
@@ -317,37 +308,4 @@ export namespace schema {
     ]),
     'The result of broadcasting an MPP credential.',
   )
-
-  /** Temporary response returned while MPP relay settlement is disabled. */
-  export const Unavailable = Schema.describe(
-    z.object({
-      error: z.object({
-        code: z
-          .literal(relayErrorCode.temporarilyUnavailable)
-          .check(z.describe('The retryable relay failure code.')),
-        message: z
-          .literal('MPP relay is not enabled yet.')
-          .check(z.describe('The retryable relay failure message.')),
-      }),
-      success: z.literal(false).check(z.describe('Whether the relay processed the credential.')),
-    }),
-    'A retryable response returned while MPP relay settlement is disabled.',
-  )
-}
-
-/** Returns the relay-disabled response while retaining its published success contract. */
-export function unavailable<success>(
-  c: Context<App.Environment>,
-): TypedResponse<success, 200> | TypedResponse<Unavailable, 503> {
-  c.header('Retry-After', '60')
-  return c.json(
-    Response.validated(schema.Unavailable, {
-      error: {
-        code: relayErrorCode.temporarilyUnavailable,
-        message: 'MPP relay is not enabled yet.',
-      },
-      success: false,
-    }),
-    503,
-  )
 }

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

@@ -1,6 +1,16 @@
-import type * as Mpp from '../Mpp.js'
+import * as Mppx from 'mppx'
+import { tempo } from 'mppx/server'
+import type { LocalAccount } from 'viem/accounts'
 
-/** Future MPPX lifecycle adapter. */
+import type * as Viem from '../../../internal/Viem.js'
+import * as Store from '../../../internal/Store.js'
+import * as Mpp from '../Mpp.js'
+import * as MppError from './Error.js'
+import * as Screening from './Screening.js'
+import * as ScreenManager from './ScreenManager.js'
+import * as Utils from './Utils.js'
+
+/** MPPX lifecycle adapter. */
 export type Adapter = {
   /** Broadcasts a validated MPP credential. */
   broadcast(input: Mpp.RelayInput): Promise<Mpp.BroadcastResponse>
@@ -8,4 +18,99 @@ export type Adapter = {
   verify(input: Mpp.RelayInput): Promise<Mpp.VerifyResponse>
 }
 
-// TODO(mppx#597): implement with validateCredential and broadcastCredential.
+/** Creates an adapter for Tempo charge credentials. */
+export function create(options: create.Options): Adapter {
+  const {
+    chainId,
+    feePayer,
+    getClient,
+    provider = Screening.allowAll,
+    reportUnknown,
+    screeningStore,
+    screeningTtl = Screening.defaultTtl,
+    state,
+    time = (_, fn) => fn(),
+  } = options
+  const screenManager = ScreenManager.create({
+    chainId,
+    provider,
+    store: screeningStore,
+    ttl: screeningTtl,
+  })
+  const methods = [
+    tempo.charge({
+      ...(feePayer ? { feePayer } : {}),
+      getClient: ({ chainId: chainId_option }) =>
+        getClient(chainId_option as Viem.ChainId | undefined),
+      store: Utils.mppxStore(state),
+    }),
+  ] as const
+
+  /** Validates and screens a credential, rejecting when either check fails. */
+  async function validateOrThrow(input: Mpp.RelayInput) {
+    const result = await time('mpp_validate', () =>
+      Mppx.Method.validateCredential(methods, Mppx.Credential.from(input)),
+    )
+    await time('mpp_screen', () => screenManager.screen(Utils.addresses(result)))
+  }
+
+  function failure(cause: unknown, operation: 'broadcast' | 'verify') {
+    const error = MppError.map(cause)
+    if (error.code === Mpp.relayErrorCode.unknown) reportUnknown?.({ operation })
+    return { error, success: false } as const
+  }
+
+  return {
+    async broadcast(input) {
+      try {
+        await validateOrThrow(input)
+        const result = await time('mpp_broadcast', () =>
+          Mppx.Method.broadcastCredential(methods, Mppx.Credential.from(input)),
+        )
+        return {
+          receipt: {
+            ...(result.externalId ? { externalId: result.externalId } : {}),
+            method: result.method,
+            reference: result.reference,
+            timestamp: result.timestamp,
+          },
+          success: true,
+        }
+      } catch (cause) {
+        return failure(cause, 'broadcast')
+      }
+    },
+    async verify(input) {
+      try {
+        await validateOrThrow(input)
+        return { success: true }
+      } catch (cause) {
+        return failure(cause, 'verify')
+      }
+    },
+  }
+}
+
+export declare namespace create {
+  /** Dependencies used to validate and broadcast Tempo credentials. */
+  type Options = {
+    /** Default Tempo chain for challenges that omit a chain id. */
+    chainId: number
+    /** Optional account used to sponsor Tempo pull transactions. */
+    feePayer?: LocalAccount | undefined
+    /** Resolves a Tempo client for each credential chain. */
+    getClient: Viem.GetClient
+    /** Address-screening provider. */
+    provider?: Screening.Provider | undefined
+    /** Reports an unexpected relay failure without passing through its cause. */
+    reportUnknown?: ((options: { operation: 'broadcast' | 'verify' }) => void) | undefined
+    /** Cache used for screening results. */
+    screeningStore: Store.Store
+    /** Screening-cache duration. @default `Ttl.days(1)` */
+    screeningTtl?: number | undefined
+    /** Durable state used for MPPX replay protection. */
+    state: Store.State
+    /** Measures a named relay operation. */
+    time?: (<value>(name: string, fn: () => Promise<value>) => Promise<value>) | undefined
+  }
+}

package/src/apps/mpp/internal/Error.test.ts

@@ -0,0 +1,33 @@
+import * as Mppx from 'mppx'
+
+import * as Mpp from '../Mpp.js'
+import * as MppError from './Error.js'
+import * as ScreenManager from './ScreenManager.js'
+
+describe('map', () => {
+  test.each([
+    [new Mppx.Errors.PaymentMethodUnsupportedError(), Mpp.relayErrorCode.unsupported],
+    [new Mppx.Errors.PaymentExpiredError(), Mpp.relayErrorCode.expired],
+    [new Mppx.Errors.InsufficientBalanceError(), Mpp.relayErrorCode.insufficientFunds],
+    [new Mppx.Errors.PaymentInsufficientError(), Mpp.relayErrorCode.insufficientFunds],
+    [
+      new Mppx.Errors.InvalidChallengeError({ reason: 'already used' }),
+      Mpp.relayErrorCode.alreadyUsed,
+    ],
+    [new Mppx.Errors.InvalidChallengeError(), Mpp.relayErrorCode.invalidPayment],
+    [new Mppx.Errors.InvalidPayloadError(), Mpp.relayErrorCode.invalidPayment],
+    [new Mppx.Errors.InvalidSignatureError(), Mpp.relayErrorCode.invalidPayment],
+    [new Mppx.Errors.MalformedCredentialError(), Mpp.relayErrorCode.invalidPayment],
+    [new Mppx.Errors.VerificationFailedError(), Mpp.relayErrorCode.invalidPayment],
+    [
+      new Mppx.Errors.VerificationFailedError({ reason: 'Transaction hash has already been used' }),
+      Mpp.relayErrorCode.alreadyUsed,
+    ],
+    [new ScreenManager.RejectedError(), Mpp.relayErrorCode.screenRejected],
+    [new Error('Transaction simulation failed.'), Mpp.relayErrorCode.simulationFailed],
+    [new Error('Transaction broadcast failed.'), Mpp.relayErrorCode.broadcastFailed],
+    [new Error('Unexpected failure.'), Mpp.relayErrorCode.unknown],
+  ] as const)('maps %s', (cause, code) => {
+    expect(MppError.map(cause)).toMatchObject({ code })
+  })
+})

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

@@ -1,9 +1,47 @@
-import type * as Mpp from '../Mpp.js'
+import * as Mppx from 'mppx'
 
-/** Future MPPX failure mapper. */
-export type Mapper = {
-  /** Maps an MPPX failure to the stable public relay error contract. */
-  map(cause: unknown): Mpp.RelayError
+import * as Mpp from '../Mpp.js'
+import * as Policy from './Policy.js'
+import * as ScreenManager from './ScreenManager.js'
+
+/** Maps an MPPX failure to the public relay error contract. */
+export function map(cause: unknown): Mpp.RelayError {
+  const message = cause instanceof Error ? cause.message : undefined
+
+  switch (true) {
+    case cause instanceof ScreenManager.RejectedError:
+      return error(Mpp.relayErrorCode.screenRejected, 'Address screening rejected the payment.')
+    case cause instanceof Policy.UnsupportedChainError:
+    case cause instanceof Mppx.Errors.PaymentMethodUnsupportedError:
+      return error(Mpp.relayErrorCode.unsupported, message)
+    case cause instanceof Policy.PolicyDeniedError:
+      return error(Mpp.relayErrorCode.policyDenied, message)
+    case cause instanceof Mppx.Errors.PaymentExpiredError:
+      return error(Mpp.relayErrorCode.expired, message)
+    case cause instanceof Mppx.Errors.InsufficientBalanceError:
+    case cause instanceof Mppx.Errors.PaymentInsufficientError:
+      return error(Mpp.relayErrorCode.insufficientFunds, message)
+    case cause instanceof Mppx.Errors.InvalidChallengeError:
+    case cause instanceof Mppx.Errors.VerificationFailedError:
+      return error(
+        /\balready (?:been )?used\b/i.test(message ?? '')
+          ? Mpp.relayErrorCode.alreadyUsed
+          : Mpp.relayErrorCode.invalidPayment,
+        message,
+      )
+    case cause instanceof Mppx.Errors.InvalidPayloadError:
+    case cause instanceof Mppx.Errors.InvalidSignatureError:
+    case cause instanceof Mppx.Errors.MalformedCredentialError:
+      return error(Mpp.relayErrorCode.invalidPayment, message)
+    case message?.toLowerCase().includes('simulation'):
+      return error(Mpp.relayErrorCode.simulationFailed, message)
+    case message?.toLowerCase().includes('broadcast'):
+      return error(Mpp.relayErrorCode.broadcastFailed, message)
+    default:
+      return error(Mpp.relayErrorCode.unknown, message)
+  }
 }
 
-// TODO(mppx#597): map validation, replay, simulation, and broadcast failures.
+function error(code: Mpp.RelayErrorCode, message: string | undefined): Mpp.RelayError {
+  return message === undefined ? { code } : { code, message }
+}

package/src/apps/mpp/internal/Idempotency.test.ts

@@ -0,0 +1,213 @@
+import * as Store from '../../../internal/Store.js'
+import * as Ttl from '../../../internal/Ttl.js'
+import * as Mpp from '../Mpp.js'
+import * as Idempotency from './Idempotency.js'
+
+const identity = {
+  apiKeyId: 'key_mpp',
+  idempotencyKey: 'mpp_broadcast_01j3j1k2l3m4n5p6q7r8s9t0u',
+  inputHash: `0x${'11'.repeat(32)}`,
+}
+
+const credential = {
+  challenge: {
+    id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0u',
+    intent: 'charge',
+    method: 'tempo',
+    realm: 'merchant.example',
+    request: { amount: '1', currency: 'USD' },
+  },
+  payload: { hash: `0x${'22'.repeat(32)}`, type: 'hash' },
+} satisfies Mpp.RelayInput
+
+describe('inputHash', () => {
+  test('binds semantic credential content instead of JSON property order', () => {
+    const reordered = {
+      payload: { hash: `0x${'22'.repeat(32)}`, type: 'hash' },
+      challenge: {
+        method: 'tempo',
+        realm: 'merchant.example',
+        request: { currency: 'USD', amount: '1' },
+        intent: 'charge',
+        id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0u',
+      },
+    } satisfies Mpp.RelayInput
+
+    expect(Idempotency.inputHash(reordered)).toBe(Idempotency.inputHash(credential))
+    expect(
+      Idempotency.inputHash({
+        ...credential,
+        challenge: { ...credential.challenge, id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0v' },
+      }),
+    ).not.toBe(Idempotency.inputHash(credential))
+  })
+})
+
+describe('claim', () => {
+  test('coordinates concurrent broadcasts and replays terminal results', async () => {
+    const state = Store.memory()
+    const claims = await Promise.all([
+      Idempotency.claim({ identity, state }),
+      Idempotency.claim({ identity, state }),
+    ])
+    const claimed = claims.find((result) => result.type === 'claimed')
+    const pending = claims.find((result) => result.type === 'pending')
+
+    expect(claimed?.type).toBe('claimed')
+    expect(pending).toEqual({ type: 'pending' })
+    if (!claimed || claimed.type !== 'claimed') throw new Error('Expected a claimed challenge.')
+
+    const response = {
+      receipt: {
+        method: 'tempo',
+        reference: `0x${'22'.repeat(32)}`,
+        timestamp: '2026-07-20T18:30:00.000Z',
+      },
+      success: true,
+    } satisfies Mpp.BroadcastResponse
+    await Idempotency.complete({ identity, response, state, token: claimed.token })
+
+    await expect(Idempotency.claim({ identity, state })).resolves.toEqual({
+      response,
+      type: 'replay',
+    })
+  })
+
+  test('reclaims a pending request after its confirmation lease expires', async () => {
+    vi.useFakeTimers({ now: new Date('2026-07-22T00:00:00.000Z') })
+    try {
+      const state = Store.memory()
+      await Idempotency.claim({ identity, state })
+      vi.advanceTimersByTime(Ttl.seconds(5) + 1)
+
+      await expect(Idempotency.claim({ identity, state })).resolves.toEqual({ type: 'pending' })
+
+      vi.advanceTimersByTime(Ttl.minutes(1) - Ttl.seconds(5))
+
+      await expect(Idempotency.claim({ identity, state })).resolves.toMatchObject({
+        type: 'claimed',
+      })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('retains a successful receipt beyond the MPP request', async () => {
+    vi.useFakeTimers({ now: new Date('2026-07-22T00:00:00.000Z') })
+    try {
+      const state = Store.memory()
+      const claim = await Idempotency.claim({ identity, state })
+      if (claim.type !== 'claimed') throw new Error('Expected an idempotency key claim.')
+      await Idempotency.complete({
+        identity,
+        response: {
+          receipt: {
+            method: 'tempo',
+            reference: `0x${'22'.repeat(32)}`,
+            timestamp: '2026-07-22T00:00:00.000Z',
+          },
+          success: true,
+        },
+        state,
+        token: claim.token,
+      })
+      vi.advanceTimersByTime(Ttl.seconds(5) + 1)
+
+      await expect(Idempotency.claim({ identity, state })).resolves.toMatchObject({
+        type: 'replay',
+      })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('rejects a reused key for a different credential', async () => {
+    const state = Store.memory()
+    const claim = await Idempotency.claim({ identity, state })
+    if (claim.type !== 'claimed') throw new Error('Expected an idempotency key claim.')
+    await Idempotency.complete({
+      identity,
+      response: {
+        receipt: {
+          method: 'tempo',
+          reference: `0x${'22'.repeat(32)}`,
+          timestamp: '2026-07-22T00:00:00.000Z',
+        },
+        success: true,
+      },
+      state,
+      token: claim.token,
+    })
+
+    await expect(
+      Idempotency.claim({
+        identity: { ...identity, inputHash: `0x${'33'.repeat(32)}` },
+        state,
+      }),
+    ).resolves.toEqual({ type: 'mismatch' })
+  })
+
+  test('does not replay a legacy receipt without an input hash', async () => {
+    const state = Store.memory()
+    const claim = await Idempotency.claim({ identity, state })
+    if (claim.type !== 'claimed') throw new Error('Expected an idempotency key claim.')
+    const key = (await state.list()).keys[0]?.name
+    if (!key) throw new Error('Expected an idempotency record.')
+    await state.put(
+      key,
+      JSON.stringify({
+        response: {
+          receipt: {
+            method: 'tempo',
+            reference: `0x${'22'.repeat(32)}`,
+            timestamp: '2026-07-22T00:00:00.000Z',
+          },
+          success: true,
+        },
+        type: 'complete',
+      }),
+    )
+
+    await expect(Idempotency.claim({ identity, state })).resolves.toEqual({ type: 'mismatch' })
+  })
+
+  test('rejects a different credential while the original request is pending', async () => {
+    const state = Store.memory()
+    const claim = await Idempotency.claim({ identity, state })
+    if (claim.type !== 'claimed') throw new Error('Expected an idempotency key claim.')
+
+    await expect(
+      Idempotency.claim({
+        identity: { ...identity, inputHash: `0x${'33'.repeat(32)}` },
+        state,
+      }),
+    ).resolves.toEqual({ type: 'mismatch' })
+    await expect(Idempotency.claim({ identity, state })).resolves.toEqual({ type: 'pending' })
+  })
+})
+
+describe('release', () => {
+  test('permits a retry after a retryable failure', async () => {
+    const state = Store.memory()
+    const result = await Idempotency.claim({ identity, state })
+    if (result.type !== 'claimed') throw new Error('Expected a claimed challenge.')
+
+    await Idempotency.release({ identity, state, token: result.token })
+
+    await expect(Idempotency.claim({ identity, state })).resolves.toMatchObject({ type: 'claimed' })
+  })
+
+  test("does not release another credential's pending claim", async () => {
+    const state = Store.memory()
+    const claim = await Idempotency.claim({ identity, state })
+    if (claim.type !== 'claimed') throw new Error('Expected an idempotency key claim.')
+
+    await Idempotency.release({
+      identity: { ...identity, inputHash: `0x${'33'.repeat(32)}` },
+      state,
+      token: claim.token,
+    })
+
+    await expect(Idempotency.claim({ identity, state })).resolves.toEqual({ type: 'pending' })
+  })
+})

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

@@ -1,7 +1,61 @@
-/** Future challenge-derived broadcast idempotency identity. */
-export type Identity = {
-  /** MPP challenge identifier. */
-  challengeId: string
+import * as core_Idempotency from '../../../internal/Idempotency.js'
+import * as Ttl from '../../../internal/Ttl.js'
+import type * as Mpp from '../Mpp.js'
+
+/**
+ * API-level retry coordination for `POST /v1/mpp/broadcast`, backed by the
+ * shared coordinator in `internal/Idempotency.ts`.
+ *
+ * MPPX consumes payment proofs, preventing settlement replay. This module instead lets a caller recover a successful receipt after a transport timeout.
+ */
+
+/** Identity for one caller-supplied idempotent broadcast request. */
+export type Identity = core_Idempotency.Identity
+
+const broadcast = core_Idempotency.create<Mpp.BroadcastResponse>({
+  namespace: 'mpp:relay:v1',
+  // Covers the confirmation wait after a credential has passed its
+  // five-second validity window.
+  pendingTtl: Ttl.minutes(1),
+  // Retains a successful settlement receipt for client recovery after
+  // transport failures.
+  receiptTtl: Ttl.days(1),
+})
+
+/** Returns a stable digest without retaining credential contents in durable state. */
+export function inputHash(input: Mpp.RelayInput) {
+  return core_Idempotency.inputHash(input)
+}
+
+/** Claims a broadcast request or returns its current outcome. */
+export function claim(options: claim.Options): Promise<claim.Result> {
+  return broadcast.claim(options)
+}
+
+export declare namespace claim {
+  /** Outcome from attempting to claim an idempotency key. */
+  type Result = core_Idempotency.claim.Result<Mpp.BroadcastResponse>
+
+  /** Dependencies for claiming one idempotency key. */
+  type Options = core_Idempotency.claim.Options
+}
+
+/** Persists a successful response for an owned request claim. */
+export function complete(options: complete.Options): Promise<void> {
+  return broadcast.complete(options)
+}
+
+export declare namespace complete {
+  /** Dependencies for persisting one terminal broadcast response. */
+  type Options = core_Idempotency.complete.Options<Mpp.BroadcastResponse>
+}
+
+/** Releases an owned retryable request claim. */
+export function release(options: release.Options): Promise<void> {
+  return broadcast.release(options)
 }
 
-// TODO(mppx#597): persist terminal broadcast results in Durable Object state.
+export declare namespace release {
+  /** Dependencies for releasing one idempotency claim. */
+  type Options = core_Idempotency.release.Options
+}

package/src/apps/mpp/internal/Policy.test.ts

@@ -0,0 +1,122 @@
+import { privateKeyToAccount } from 'viem/accounts'
+
+import * as StripeCustomers from '../../../db/tables/stripeCustomers.js'
+import * as TestApp from '../../../../test/App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Mpp from '../Mpp.js'
+import * as Policy from './Policy.js'
+
+const feePayer = privateKeyToAccount(`0x${'11'.repeat(32)}`)
+
+const input = {
+  challenge: {
+    id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0u',
+    intent: 'charge',
+    method: 'tempo',
+    realm: 'merchant.example',
+    request: { chainId: 4217, methodDetails: { chainId: 42431, feePayer: true } },
+  },
+  payload: {},
+} satisfies Mpp.RelayInput
+
+const principal = {
+  apiKey: { environment: 'production', id: 'key_mpp', orgId: 'org_mpp', scopes: ['mpp:write'] },
+  environment: 'production',
+  id: 'key_mpp',
+  orgId: 'org_mpp',
+  projectId: 'prj_mpp',
+  type: 'api_key',
+} satisfies Auth.Principal
+const { projectId: _, ...principal_projectless } = principal
+
+describe('chainId', () => {
+  test('uses the method-specific chain before the request fallback', () => {
+    expect(Policy.chainId(input)).toBe(42431)
+  })
+})
+
+describe('requiresFeePayer', () => {
+  test('requires both a fee-payer method detail and an enabled request', () => {
+    expect(Policy.requiresFeePayer(input)).toBe(true)
+    expect(
+      Policy.requiresFeePayer({
+        ...input,
+        challenge: {
+          ...input.challenge,
+          request: { methodDetails: { feePayer: true }, feePayer: false },
+        },
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('assertSupportedChain', () => {
+  test('rejects chains outside the deployment allowlist', () => {
+    expect(() =>
+      Policy.assertSupportedChain({ chainId: 1, supportedChainIds: new Set([4217]) }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Mpp.Policy.UnsupportedChainError: Unsupported chain id 1.]`,
+    )
+  })
+})
+
+describe('authorizeFeePayer', () => {
+  test('allows organization attribution for sponsored credentials', async () => {
+    await expect(
+      Policy.authorizeFeePayer({
+        chainId: 42431,
+        db: TestApp.database(),
+        feePayer,
+        input,
+        principal: principal_projectless,
+      }),
+    ).resolves.toBe(feePayer)
+  })
+
+  test('bills a projectless mainnet sponsored credential to its organization', async () => {
+    const db = TestApp.database()
+
+    await expect(
+      Policy.authorizeFeePayer({
+        chainId: 4217,
+        db,
+        feePayer,
+        input,
+        principal: principal_projectless,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Mpp.Policy.PolicyDeniedError: Active billing is required for mainnet fee sponsorship.]`,
+    )
+
+    await StripeCustomers.create(db, {
+      orgId: principal_projectless.orgId,
+      stripeCustomerId: 'cus_mpp',
+    })
+    await StripeCustomers.setStatus(db, principal_projectless.orgId, 'active')
+
+    await expect(
+      Policy.authorizeFeePayer({
+        chainId: 4217,
+        db,
+        feePayer,
+        input,
+        principal: principal_projectless,
+      }),
+    ).resolves.toBe(feePayer)
+  })
+
+  test('does not require billing when the credential pays its own fee', async () => {
+    await expect(
+      Policy.authorizeFeePayer({
+        chainId: 4217,
+        db: TestApp.database(),
+        feePayer,
+        input: {
+          ...input,
+          challenge: { ...input.challenge, request: { methodDetails: { feePayer: false } } },
+        },
+        principal,
+      }),
+    ).resolves.toBe(feePayer)
+  })
+})