tapimo 0.6.0 → 0.7.0

package/src/apps/mpp/Mpp.ts

@@ -0,0 +1,353 @@
+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. */
+export const relayErrorCode = {
+  /** Credential or transaction already used. */
+  alreadyUsed: 'already_used',
+  /** Transaction broadcast or confirmation failed. */
+  broadcastFailed: 'broadcast_failed',
+  /** Challenge or payment authorization expired. */
+  expired: 'expired',
+  /** Payload, signature, parties, or payment requirements are invalid. */
+  invalidPayment: 'invalid_payment',
+  /** Sender lacks funds. */
+  insufficientFunds: 'insufficient_funds',
+  /** Payment violates relay or account policy. */
+  policyDenied: 'policy_denied',
+  /** Originator or recipient failed screening. */
+  screenRejected: 'screen_rejected',
+  /** Transaction simulation failed before broadcast. */
+  simulationFailed: 'simulation_failed',
+  /** Retry may succeed. */
+  temporarilyUnavailable: 'temporarily_unavailable',
+  /** Method, intent, network, or asset is unsupported. */
+  unsupported: 'unsupported',
+  /** Unexpected relay failure. */
+  unknown: 'unknown',
+} as const
+
+/** Stable MPP relay failure code. */
+export type RelayErrorCode = (typeof relayErrorCode)[keyof typeof relayErrorCode]
+
+/** MPP relay error response. */
+export type RelayError = {
+  /** Stable machine-readable reason the relay rejected the credential. */
+  code: RelayErrorCode
+  /** Human-readable explanation of the relay result. */
+  message?: string | undefined
+}
+
+/** MPP challenge accepted with a relay credential payload. */
+export type Challenge = {
+  /** Additional MPP challenge metadata, preserved verbatim for validation. */
+  [key: string]: unknown
+  /** Human-readable payment description. */
+  description?: string | undefined
+  /** When the payment challenge expires, as an ISO-8601 timestamp. */
+  expires?: string | undefined
+  /** Payment challenge identifier. */
+  id: string
+  /** MPP payment intent. */
+  intent: string
+  /** MPP payment method. */
+  method: string
+  /** Opaque data bound to the challenge by its issuer. */
+  opaque?: string | undefined
+  /** MPP realm that issued the challenge. */
+  realm: string
+  /** Payment request bound to the challenge. */
+  request: Record<string, unknown>
+}
+
+/** MPP challenge and credential payload accepted by the relay. */
+export type RelayInput = {
+  /** Payment challenge supplied with the credential. */
+  challenge: Challenge
+  /** Method-specific MPP credential payload. */
+  payload: unknown
+}
+
+/** Broadcast MPP payment receipt. */
+export type Receipt = {
+  /** Optional caller-provided payment reference. */
+  externalId?: string | undefined
+  /** Payment method that settled the credential. */
+  method: string
+  /** On-chain or payment-system settlement reference. */
+  reference: string
+  /** When the payment settled, as an ISO-8601 timestamp. */
+  timestamp: string
+}
+
+/** MPP credential validation response. */
+export type VerifyResponse = { success: true } | { error: RelayError; success: false }
+
+/** MPP credential broadcast response. */
+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] }))
+}
+
+/** MPP relay schemas. */
+export namespace schema {
+  /** Stable MPP relay failure codes. */
+  export const ErrorCode = Schema.describe(
+    z.union([
+      errorCode(relayErrorCode.unsupported, 'Method, intent, network, or asset is unsupported.'),
+      errorCode(relayErrorCode.policyDenied, 'Payment violates relay or account policy.'),
+      errorCode(
+        relayErrorCode.invalidPayment,
+        'Payload, signature, parties, or payment requirements are invalid.',
+      ),
+      errorCode(relayErrorCode.insufficientFunds, 'Sender lacks funds.'),
+      errorCode(relayErrorCode.expired, 'Challenge or payment authorization expired.'),
+      errorCode(relayErrorCode.alreadyUsed, 'Credential or transaction already used.'),
+      errorCode(relayErrorCode.screenRejected, 'Originator or recipient failed screening.'),
+      errorCode(relayErrorCode.simulationFailed, 'Transaction simulation failed before broadcast.'),
+      errorCode(relayErrorCode.broadcastFailed, 'Transaction broadcast or confirmation failed.'),
+      errorCode(relayErrorCode.temporarilyUnavailable, 'Retry may succeed.'),
+      errorCode(relayErrorCode.unknown, 'Unexpected relay failure.'),
+    ]),
+    'A stable machine-readable reason the MPP relay rejected or could not process a payment.',
+  )
+
+  /** Error returned by the MPP relay. */
+  export const RelayError = Schema.describe(
+    z
+      .object({
+        code: ErrorCode,
+        message: z
+          .optional(z.string())
+          .check(
+            z.describe('A human-readable explanation of the relay result.'),
+            z.meta({ examples: ['MPP relay is not enabled yet.'] }),
+          ),
+      })
+      .check(
+        z.meta({
+          examples: [
+            {
+              code: relayErrorCode.temporarilyUnavailable,
+              message: 'MPP relay is not enabled yet.',
+            },
+          ],
+        }),
+      ),
+    'An error returned by the MPP relay.',
+  )
+
+  /** MPP challenge accepted with a relay credential payload. */
+  export const Challenge = Schema.describe(
+    z.looseObject({
+      description: z
+        .optional(z.string())
+        .check(
+          z.describe('A human-readable description of the payment.'),
+          z.meta({ examples: ['Tempo API payment'] }),
+        ),
+      expires: z
+        .optional(z.string())
+        .check(
+          z.describe('When the payment challenge expires, as an ISO-8601 timestamp.'),
+          z.meta({ examples: ['2026-07-21T21:30:00.000Z'] }),
+        ),
+      id: z
+        .string()
+        .check(
+          z.describe('The payment challenge identifier.'),
+          z.meta({ examples: ['ch_01j3j1k2l3m4n5p6q7r8s9t0u'] }),
+        ),
+      intent: z
+        .string()
+        .check(z.describe('The MPP payment intent.'), z.meta({ examples: ['charge'] })),
+      method: z
+        .string()
+        .check(z.describe('The MPP payment method.'), z.meta({ examples: ['tempo'] })),
+      opaque: z
+        .optional(z.string())
+        .check(
+          z.describe('Opaque data bound to the challenge by its issuer.'),
+          z.meta({ examples: ['eyJhbGciOiJIUzI1NiJ9'] }),
+        ),
+      realm: z
+        .string()
+        .check(
+          z.describe('The MPP realm that issued the challenge.'),
+          z.meta({ examples: ['merchant.example'] }),
+        ),
+      request: z
+        .record(z.string(), z.unknown())
+        .check(
+          z.describe('The payment request bound to the challenge.'),
+          z.meta({ examples: [{ amount: '1', currency: 'USD' }] }),
+        ),
+    }),
+    'An MPP payment challenge.',
+  )
+
+  /** Request accepted by MPP relay verification and broadcast routes. */
+  export const RelayInput = Schema.describe(
+    z.object({
+      challenge: Challenge,
+      payload: z
+        .custom<unknown>((value) => value !== undefined)
+        .check(
+          z.describe('The method-specific MPP credential payload.'),
+          z.meta({ examples: [{ signature: `0x${'aa'.repeat(65)}`, type: 'transaction' }] }),
+        ),
+    }),
+    'An MPP payment credential and its challenge.',
+  )
+
+  /** Receipt returned after the relay broadcasts a payment. */
+  export const Receipt = Schema.describe(
+    z.object({
+      externalId: z
+        .optional(z.string())
+        .check(
+          z.describe('An optional caller-provided payment reference.'),
+          z.meta({ examples: ['pi_01j3j1k2l3m4n5p6q7r8s9t0u'] }),
+        ),
+      method: z
+        .string()
+        .check(
+          z.describe('The payment method that settled the credential.'),
+          z.meta({ examples: ['tempo'] }),
+        ),
+      reference: z
+        .string()
+        .check(
+          z.describe('The on-chain or payment-system reference for the settlement.'),
+          z.meta({ examples: [`0x${'22'.repeat(32)}`] }),
+        ),
+      timestamp: z
+        .string()
+        .check(
+          z.describe('When the payment settled, as an ISO-8601 timestamp.'),
+          z.meta({ examples: ['2026-07-20T18:30:00.000Z'] }),
+        ),
+    }),
+    'A receipt for a broadcast MPP payment.',
+  )
+
+  /** Read-only MPP credential validation result. */
+  export const VerifyResponse = Schema.describe(
+    z.union([
+      z.object({
+        success: z
+          .literal(true)
+          .check(
+            z.describe('Whether the credential passed relay checks.'),
+            z.meta({ examples: [true] }),
+          ),
+      }),
+      z.object({
+        error: RelayError.check(
+          z.describe('The reason the credential did not pass relay checks.'),
+          z.meta({
+            examples: [
+              { code: relayErrorCode.invalidPayment, message: 'Credential signature is invalid.' },
+            ],
+          }),
+        ),
+        success: z
+          .literal(false)
+          .check(
+            z.describe('Whether the credential passed relay checks.'),
+            z.meta({ examples: [false] }),
+          ),
+      }),
+    ]),
+    'The result of read-only MPP credential validation.',
+  )
+
+  /** MPP credential broadcast result. */
+  export const BroadcastResponse = Schema.describe(
+    z.union([
+      z.object({
+        receipt: Receipt.check(
+          z.describe('The payment settlement receipt.'),
+          z.meta({
+            examples: [
+              {
+                method: 'tempo',
+                reference: `0x${'22'.repeat(32)}`,
+                timestamp: '2026-07-20T18:30:00.000Z',
+              },
+            ],
+          }),
+        ),
+        success: z
+          .literal(true)
+          .check(
+            z.describe('Whether the relay broadcast the credential.'),
+            z.meta({ examples: [true] }),
+          ),
+      }),
+      z.object({
+        error: RelayError.check(
+          z.describe('The reason the relay did not broadcast the credential.'),
+          z.meta({
+            examples: [
+              { code: relayErrorCode.broadcastFailed, message: 'Transaction broadcast failed.' },
+            ],
+          }),
+        ),
+        success: z
+          .literal(false)
+          .check(
+            z.describe('Whether the relay broadcast the credential.'),
+            z.meta({ examples: [false] }),
+          ),
+      }),
+    ]),
+    '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/index.ts

@@ -0,0 +1,2 @@
+export { mpp } from './App.js'
+export * as Mpp from './Mpp.js'

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

@@ -0,0 +1,11 @@
+import type * as Mpp from '../Mpp.js'
+
+/** Future MPPX lifecycle adapter. */
+export type Adapter = {
+  /** Broadcasts a validated MPP credential. */
+  broadcast(input: Mpp.RelayInput): Promise<Mpp.BroadcastResponse>
+  /** Validates an MPP credential without broadcasting it. */
+  verify(input: Mpp.RelayInput): Promise<Mpp.VerifyResponse>
+}
+
+// TODO(mppx#597): implement with validateCredential and broadcastCredential.

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

@@ -0,0 +1,9 @@
+import type * as Mpp from '../Mpp.js'
+
+/** Future MPPX failure mapper. */
+export type Mapper = {
+  /** Maps an MPPX failure to the stable public relay error contract. */
+  map(cause: unknown): Mpp.RelayError
+}
+
+// TODO(mppx#597): map validation, replay, simulation, and broadcast failures.

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

@@ -0,0 +1,7 @@
+/** Future challenge-derived broadcast idempotency identity. */
+export type Identity = {
+  /** MPP challenge identifier. */
+  challengeId: string
+}
+
+// TODO(mppx#597): persist terminal broadcast results in Durable Object state.

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

@@ -0,0 +1,10 @@
+/** Future address-screening result. */
+export type Result = { allowed: boolean }
+
+/** Future address-screening provider. */
+export type Provider = {
+  /** Screens one normalized account address on a Tempo chain. */
+  screen(options: { address: string; chainId: number }): Promise<Result>
+}
+
+// TODO(mppx#597): add concurrent cached Chainalysis screening behind this provider.

package/src/apps/relay/App.test.ts

@@ -656,6 +656,19 @@ describe.skipIf(runtime.mode !== 'localnet')('behavior: sponsorship', () => {
 // Chain-free (`eth_signRawTransaction` signs locally; the sponsor fee token
 // short-circuits resolution), so the gate matrix runs in every mode.
 describe('behavior: mainnet billing gate', () => {
+  const fill = {
+    calls: [{ to: Tempo.accounts[8]!.address, value: '0x0' }],
+    capabilities: { balanceDiffs: false },
+    chainId: Hex.fromNumber(Viem.chainId.mainnet),
+    feePayer: true,
+    feeToken: '0x20c0000000000000000000000000000000000000',
+    from: senderAccount.address,
+    gas: Hex.fromNumber(100_000),
+    maxFeePerGas: Hex.fromNumber(1_000_000),
+    maxPriorityFeePerGas: '0x0',
+    nonce: '0x0',
+  } as const
+
   function createApp(db: Db.Source = TestApp.database()) {
     return TestApp.create({
       auth: { keys },
@@ -692,6 +705,64 @@ describe('behavior: mainnet billing gate', () => {
     expect(body.error?.data).toStrictEqual({ code: 'billing_required' })
   })
 
+  test('behavior: returns the billing reason for sponsor fills', async () => {
+    const body = await relayRequest(createApp(), {
+      method: 'eth_fillTransaction',
+      params: [fill],
+      token: 'secret_sponsor_prod',
+    })
+    expect(body.error).toStrictEqual({
+      code: -32602,
+      data: { code: 'billing_required' },
+      message: 'Billing required.',
+    })
+  })
+
+  test('behavior: relay fills still fall back to self-payment', async () => {
+    const server = await Relay.createServer(
+      RequestListener.fromFetchHandler(async (request) => {
+        type Rpc = {
+          id: number
+          method: string
+          params: readonly [Record<string, unknown>]
+        }
+        const rpc = (await request.json()) as Rpc
+        if (rpc.method !== 'eth_fillTransaction')
+          return Response.json({ id: rpc.id, jsonrpc: '2.0', result: '0x' })
+        return Response.json({
+          id: rpc.id,
+          jsonrpc: '2.0',
+          result: { capabilities: {}, tx: rpc.params[0] },
+        })
+      }),
+    )
+    try {
+      const body = await relayRequest(
+        TestApp.create({
+          auth: { keys },
+          db: TestApp.database(),
+          relay: { feePayer: { account: feePayerAccount } },
+          rpc: { url: () => server.url },
+          supportedChainIds: [Viem.chainId.mainnet],
+        }),
+        {
+          method: 'eth_fillTransaction',
+          mount: 'relay',
+          params: [fill],
+          token: 'secret_wildcard_prod',
+        },
+      )
+      type Result = {
+        capabilities?: { sponsored?: boolean | undefined } | undefined
+      }
+      const result = body.result as unknown as Result
+      expect(body.error).toBeUndefined()
+      expect(result.capabilities?.sponsored).toBe(false)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
   test('behavior: refuses mainnet sponsorship while billing is inactive', async () => {
     const db = TestApp.database()
     await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_gate' })
@@ -1110,13 +1181,10 @@ async function signSponsorable(
   })
 }
 
-/** Posts one JSON-RPC request to the composed app's sponsor mount. */
-async function relayRequest(
-  app: ReturnType<typeof TestApp.create>,
-  options: { method: string; params: readonly unknown[]; token?: string | undefined },
-) {
+/** Posts one JSON-RPC request to a composed relay mount. */
+async function relayRequest(app: ReturnType<typeof TestApp.create>, options: relayRequest.Options) {
   const response = await app.fetch(
-    new Request('http://tempo-api.test/rpc/sponsor', {
+    new Request(`http://tempo-api.test/rpc/${options.mount ?? 'sponsor'}`, {
       body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: options.method, params: options.params }), // prettier-ignore
       headers: {
         'content-type': 'application/json',
@@ -1131,6 +1199,20 @@ async function relayRequest(
   }
 }
 
+declare namespace relayRequest {
+  /** Options for one composed relay request. */
+  type Options = {
+    /** JSON-RPC method. */
+    method: string
+    /** Relay mount to call. */
+    mount?: 'relay' | 'sponsor' | undefined
+    /** JSON-RPC parameters. */
+    params: readonly unknown[]
+    /** API-key credential. */
+    token?: string | undefined
+  }
+}
+
 // The full billing-to-invoice flow with nothing synthetic: a disposable node
 // runs under mainnet's chain id (dev consensus, funded dev alloc), so a real
 // card attach opens the real gate, a real sponsored transaction mines with a

package/src/apps/relay/App.ts

@@ -8,6 +8,7 @@ import type * as App from '../../App.js'
 import * as BillingSettings from '../../db/tables/billingSettings.js'
 import * as Db from '../../db/Db.js'
 import * as Fees from '../../internal/Fees.js'
+import * as Log from '../../internal/Log.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
 import * as Billing from '../management/Billing.js'
 import * as Handler from '../../Handler.js'
@@ -75,6 +76,9 @@ export declare namespace relay {
 // Builds request-aware RPC middleware. Viem clients are memoized upstream, so
 // constructing `Handler.relay` per request stays cheap.
 function middleware(options: middleware.Options) {
+  // The sponsor mount promises a fee-payer signature. The relay mount may
+  // fall back to self-payment when policy refuses sponsorship.
+  const sponsorshipRequired = options.path === 'rpc/sponsor'
   // Platform-wide per-transaction cap; org settings tighten it, never loosen.
   const txFeeLimit = options.feePayer
     ? Billing.toBaseUnits(options.feePayer.txFeeLimit ?? '1.00')
@@ -111,12 +115,20 @@ function middleware(options: middleware.Options) {
           // only mainnet: the relay resolves chainId from the request body, so
           // the query-string chain guard never sees it.
           const id = Number(transaction.chainId)
-          if (!attribution || !sponsorable || !c.get('supportedChainIds').has(id)) return false
+          if (!attribution || !sponsorable || !c.get('supportedChainIds').has(id)) {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({ message: 'Sponsorship rejected.' })
+            return false
+          }
           if (!Viem.isMainnet(id)) return true
           // Mainnet is production-only: a sandbox key resolves chainId from the
           // request body, so the auth-layer sandbox/mainnet guard never sees
           // it. Refuse here, or sandbox spend would sponsor mainnet unbilled.
-          if (attribution.environment !== 'production') return false
+          if (attribution.environment !== 'production') {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({ message: 'Sponsorship rejected.' })
+            return false
+          }
 
           // Enforcement reads hit the primary, never the cached replica: a
           // stale `past_due`, a lowered limit, or another isolate's pending
@@ -127,8 +139,22 @@ function middleware(options: middleware.Options) {
           // `past_due` gets its own reason: the caller must settle an invoice,
           // not attach a card.
           const billing = await Billing.status(db, attribution.orgId)
-          if (billing === 'past_due') return 'billing_past_due'
-          if (billing !== 'active') return 'billing_required'
+          if (billing === 'past_due') {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({
+                data: { code: 'billing_past_due' },
+                message: 'Billing past due.',
+              })
+            return 'billing_past_due'
+          }
+          if (billing !== 'active') {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({
+                data: { code: 'billing_required' },
+                message: 'Billing required.',
+              })
+            return 'billing_required'
+          }
 
           const feeToken = (() => {
             try {
@@ -144,21 +170,40 @@ function middleware(options: middleware.Options) {
             !verified ||
             verified.currency.toLowerCase() !== 'usd' ||
             verified.decimals !== Fees.tokenDecimals
-          )
-            // prettier-ignore
+          ) {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({
+                data: { code: 'fee_token_unsupported' },
+                message: 'Fee token unsupported.',
+              })
             return 'fee_token_unsupported'
+          }
 
           // Fail closed: a transaction whose signed cap cannot be computed
           // cannot be bounded, so it never sponsors on mainnet.
           const feeMax = Fees.maxOf(transaction)
-          if (feeMax === undefined) return 'tx_fee_limit_exceeded'
+          if (feeMax === undefined) {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({
+                data: { code: 'tx_fee_limit_exceeded' },
+                message: 'Transaction fee limit exceeded.',
+              })
+            return 'tx_fee_limit_exceeded'
+          }
           const settings = await BillingSettings.get(db, attribution.orgId)
           const cap = (() => {
             if (settings?.txFeeLimit == null) return txFeeLimit
             const org = Billing.toBaseUnits(settings.txFeeLimit)
             return org < txFeeLimit ? org : txFeeLimit
           })()
-          if (feeMax > cap) return 'tx_fee_limit_exceeded'
+          if (feeMax > cap) {
+            if (sponsorshipRequired)
+              throw new RpcResponse.InvalidParamsError({
+                data: { code: 'tx_fee_limit_exceeded' },
+                message: 'Transaction fee limit exceeded.',
+              })
+            return 'tx_fee_limit_exceeded'
+          }
           // The period spend limit is enforced atomically at recording time
           // (`onSponsored` → `SponsoredTransactions.reserve`); a check here
           // would be a check-then-act race a burst could slip through.
@@ -278,7 +323,14 @@ function middleware(options: middleware.Options) {
           }
         : {}),
     })
-    return handler.fetch(c.req.raw)
+    const response = await handler.fetch(c.req.raw)
+    const body: unknown = await response
+      .clone()
+      .json()
+      .catch(() => undefined)
+    const rpc = Log.rpcErrors(body)
+    if (rpc) c.set('rpcResponse', rpc)
+    return response
   })
 }
 

package/src/db/Db.test.ts

@@ -17,7 +17,7 @@ describe('postgres', () => {
     await db.close()
   })
 
-  test('behavior: legacy invitation inserts retain early access during cutover', async () => {
+  test('behavior: legacy invitation inserts do not grant early access', async () => {
     const db = create()
     await db.migrate()
     await Organizations.create(db, { id: 'org_legacy', name: 'Legacy' })
@@ -30,7 +30,7 @@ describe('postgres', () => {
       )
     `.execute(db.kysely)
 
-    expect((await Invitations.get(db, 'inv_legacy'))?.grantsEarlyAccess).toBe(true)
+    expect((await Invitations.get(db, 'inv_legacy'))?.grantsEarlyAccess).toBe(false)
     await db.close()
   })