tapimo 0.13.0 → 0.15.0

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

@@ -223,6 +223,63 @@ describe('finalize', () => {
     expect(await SponsoredTransactions.listPending(db)).toHaveLength(1)
     await db.close()
   })
+
+  test('behavior: unbroadcast transactions do not block newer receipts', async () => {
+    const db = create()
+    await db.migrate()
+    vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00.000Z'), toFake: ['Date'] })
+    await SponsoredTransactions.upsert(db, {
+      ...input,
+      orgId: 'org_attacker',
+      signPayload: `0x${'b1'.repeat(32)}`,
+      transactionHash: `0x${'a1'.repeat(32)}`,
+    })
+    vi.setSystemTime(new Date('2026-01-01T00:00:01.000Z'))
+    await SponsoredTransactions.upsert(db, {
+      ...input,
+      orgId: 'org_attacker',
+      signPayload: `0x${'b2'.repeat(32)}`,
+      transactionHash: `0x${'a2'.repeat(32)}`,
+    })
+    vi.setSystemTime(new Date('2026-01-01T00:00:02.000Z'))
+    const victim = await SponsoredTransactions.upsert(db, {
+      ...input,
+      orgId: 'org_victim',
+      signPayload: `0x${'b3'.repeat(32)}`,
+      transactionHash: `0x${'a3'.repeat(32)}`,
+    })
+    vi.setSystemTime(new Date('2026-01-01T00:00:03.000Z'))
+
+    const options = {
+      batchSize: 2,
+      getClient: () =>
+        client({
+          [victim.transactionHash!]: { effectiveGasPrice: '0x1', gasUsed: '0x1' },
+        }),
+    }
+
+    expect(await Sponsorships.finalize(db, options)).toMatchInlineSnapshot(`
+      {
+        "errors": 0,
+        "failed": 0,
+        "finalized": 0,
+        "pending": 2,
+      }
+    `)
+    vi.setSystemTime(new Date('2026-01-01T00:00:04.000Z'))
+    expect(await Sponsorships.finalize(db, options)).toMatchInlineSnapshot(`
+      {
+        "errors": 0,
+        "failed": 0,
+        "finalized": 1,
+        "pending": 1,
+      }
+    `)
+    expect((await SponsoredTransactions.get(db, victim.id))?.status).toBe('finalized')
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(2)
+    vi.useRealTimers()
+    await db.close()
+  })
 })
 
 describe('reconcile', () => {
@@ -249,8 +306,14 @@ describe('reconcile', () => {
   } as never as Client
 
   /** Fakes the indexer: the fee payer's recent transactions. */
-  const tidx = (rows: readonly { from: string; hash: string }[]) =>
-    ({ fetch: async () => ({ rows }) }) as never
+  const tidx = (
+    rows: readonly {
+      block_num?: number | undefined
+      from: string
+      hash: string
+      idx?: number | undefined
+    }[],
+  ) => ({ fetch: async () => ({ rows }) }) as never
 
   test('behavior: matches intents by sign payload and fills the hash', async () => {
     const db = create()
@@ -290,7 +353,7 @@ describe('reconcile', () => {
         return await Sponsorships.reconcile(db, {
           feePayer: '0xFee0000000000000000000000000000000000000',
           getClient: () => rpc,
-          getTidx: () => tidx([{ from: sender, hash: minedHash }]),
+          getTidx: () => tidx([{ block_num: 1, from: sender, hash: minedHash, idx: 0 }]),
         })
       } finally {
         vi.useRealTimers()
@@ -324,7 +387,7 @@ describe('reconcile', () => {
         return await Sponsorships.reconcile(db, {
           feePayer: '0xFee0000000000000000000000000000000000000',
           getClient: () => rpc,
-          getTidx: () => tidx([{ from: sender, hash: minedHash }]),
+          getTidx: () => tidx([{ block_num: 1, from: sender, hash: minedHash, idx: 0 }]),
           limitFor: async () => ({
             chainIds: [42431],
             max: -1n,

package/src/apps/relay/Sponsorships.ts

@@ -11,11 +11,16 @@ import { getTransactionReceipt } from 'viem/actions'
 
 import * as Db from '../../db/Db.js'
 import * as BillingSettings from '../../db/tables/billingSettings.js'
-import * as Fees from '../../internal/Fees.js'
+import * as Projects from '../../db/tables/projects.js'
+import * as SponsorshipAttributions from '../../db/tables/sponsorshipAttributions.js'
+import * as SponsorshipReconciliationCursors from '../../db/tables/sponsorshipReconciliationCursors.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
+import * as Fees from '../../internal/Fees.js'
 import * as Tidx from '../../internal/Tidx.js'
+import * as Value from '../../internal/Value.js'
 import * as Viem from '../../internal/Viem.js'
 import * as Billing from '../management/Billing.js'
+import * as Zones from '../Zones.js'
 
 /**
  * Runs one finalization pass over pending sponsored transactions: rows with a
@@ -37,7 +42,10 @@ export async function finalize(db: Db.Db, options: finalize.Options): Promise<fi
     receiptErrorTtlMs = 86_400_000,
   } = options
 
-  const rows = await SponsoredTransactions.listPending(db, { limit: batchSize })
+  const rows = await SponsoredTransactions.claimPending(db, {
+    attemptedAt: now().toISOString(),
+    limit: batchSize,
+  })
   const result = { errors: 0, failed: 0, finalized: 0, pending: 0 }
 
   for (const row of rows) {
@@ -136,22 +144,25 @@ export async function reconcile(db: Db.Db, options: reconcile.Options): Promise<
     skewMs = 120_000,
   } = options
 
-  const intents = await SponsoredTransactions.listIntents(db, {
-    failedSince: new Date(Date.now() - failedIntentTtlMs).toISOString(),
-    limit: batchSize,
-  })
+  const failedSince = new Date(Date.now() - failedIntentTtlMs).toISOString()
+  // Old failed intents must not move the active scan behind its candidate cap.
+  const [intents, recoveryWindows] = await Promise.all([
+    SponsoredTransactions.listIntents(db, { limit: batchSize }),
+    SponsoredTransactions.listRecoveryWindows(db, { failedSince }),
+  ])
   const result = { errors: 0, matched: 0, scanned: 0 }
-  if (intents.length === 0) return result
+  if (intents.length === 0 && recoveryWindows.length === 0) return result
 
-  const chains = new Map<number, SponsoredTransactions.Record[]>()
-  for (const intent of intents) chains.set(intent.chainId, [...(chains.get(intent.chainId) ?? []), intent]) // prettier-ignore
+  const groups = new Map<number, SponsoredTransactions.Record[]>()
+  for (const intent of intents)
+    groups.set(intent.chainId, [...(groups.get(intent.chainId) ?? []), intent])
 
-  for (const [chainId, rows] of chains) {
+  for (const [chainId, rows] of groups) {
+    if (candidateCap <= 0) continue
     const bySignPayload = new Map(rows.map((row) => [row.signPayload, row]))
-    // The intent set bounds the scan window: no cursor state to persist.
-    const since = new Date(
+    const since = formatTidxTimestamp(
       Math.min(...rows.map((row) => Date.parse(row.createdAt))) - skewMs,
-    ).toISOString()
+    )
 
     let candidates: readonly globalThis.Record<string, unknown>[]
     try {
@@ -176,7 +187,11 @@ export async function reconcile(db: Db.Db, options: reconcile.Options): Promise<
       result.scanned++
       try {
         const serialized = await getRawTransaction(getClient(chainId), hash)
-        if (!serialized?.startsWith(TxEnvelopeTempo.serializedType)) continue
+        if (!serialized) {
+          result.errors++
+          continue
+        }
+        if (!serialized.startsWith(TxEnvelopeTempo.serializedType)) continue
         const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(
           TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized),
           { sender },
@@ -197,6 +212,139 @@ export async function reconcile(db: Db.Db, options: reconcile.Options): Promise<
         if (!(error instanceof SponsoredTransactions.PeriodSpendLimitError)) result.errors++
       }
     }
+    // A truncated active scan cannot prove that the remaining intents were never mined.
+    if (candidates.length === candidateCap && bySignPayload.size > 0) result.errors++
+  }
+
+  const feePayer_lower = feePayer.toLowerCase() as Address
+  for (const window of recoveryWindows) {
+    const chainId = window.chainId
+    if (candidateCap <= 0) continue
+    const cursor = await SponsorshipReconciliationCursors.load(db, {
+      chainId,
+      feePayer: feePayer_lower,
+    })
+    const keyset = !cursor.complete
+      ? `AND block_num <= ${cursor.blockNumber} AND (block_num < ${cursor.blockNumber} OR idx < ${cursor.transactionIndex})`
+      : ''
+    const since = formatTidxTimestamp(Date.parse(window.createdAt) - skewMs)
+
+    let candidates: readonly globalThis.Record<string, unknown>[]
+    try {
+      const fetched = await getTidx(chainId).fetch({
+        chainId,
+        query:
+          `SELECT hash, "from", block_num, idx FROM txs WHERE fee_payer = '${feePayer_lower}' AND block_timestamp >= '${since}' ${keyset} ORDER BY block_num DESC, idx DESC LIMIT ${candidateCap}` as string,
+      })
+      candidates = fetched.rows
+    } catch {
+      result.errors++
+      continue
+    }
+
+    type Match = {
+      hash?: Hex.Hex | undefined
+      position: NonNullable<ReturnType<typeof candidatePosition>>
+      signPayload?: string | undefined
+    }
+    const matches: Match[] = []
+    let stopped = false
+    let retryCount = 0
+    let retryKey: string | null = null
+    for (const candidate of candidates) {
+      const position = candidatePosition(candidate)
+      if (!position) {
+        result.errors++
+        stopped = true
+        break
+      }
+      const hash = candidate['hash'] as Hex.Hex | undefined
+      const sender = candidate['from'] as Address | undefined
+      result.scanned++
+      try {
+        if (!hash || !sender) throw new Error('Missing recovery candidate identity.')
+        const serialized = await getRawTransaction(getClient(chainId), hash)
+        if (!serialized) throw new Error('Recovery candidate unavailable from RPC.')
+        if (!serialized.startsWith(TxEnvelopeTempo.serializedType)) {
+          matches.push({ position })
+          continue
+        }
+        matches.push({
+          hash,
+          position,
+          signPayload: TxEnvelopeTempo.getFeePayerSignPayload(
+            TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized),
+            { sender },
+          ),
+        })
+      } catch {
+        result.errors++
+        const key = `${position.blockNumber}:${position.transactionIndex}`
+        const attempts = cursor.retryKey === key ? cursor.retryCount + 1 : 1
+        // Retry transient failures across three passes, then revisit on the next complete scan.
+        if (attempts >= 3) {
+          matches.push({ position })
+          continue
+        }
+        retryCount = attempts
+        retryKey = key
+        stopped = true
+        break
+      }
+    }
+
+    let recoverable: SponsoredTransactions.Record[]
+    try {
+      recoverable = await SponsoredTransactions.listRecoverableIntents(db, {
+        failedSince,
+        signPayloads: matches.flatMap((match) =>
+          match.signPayload === undefined ? [] : [match.signPayload],
+        ),
+      })
+    } catch {
+      result.errors++
+      continue
+    }
+    const bySignPayload = new Map(recoverable.map((intent) => [intent.signPayload, intent]))
+    let lastProcessed: Match['position'] | undefined
+    for (const match of matches) {
+      const signPayload = match.signPayload
+      const intent = signPayload ? bySignPayload.get(signPayload) : undefined
+      if (!signPayload || !intent || !match.hash) {
+        lastProcessed = match.position
+        continue
+      }
+      try {
+        await SponsoredTransactions.assignTransactionHash(
+          db,
+          intent.id,
+          match.hash,
+          await options.limitFor?.(intent),
+        )
+        bySignPayload.delete(signPayload)
+        result.matched++
+      } catch (error) {
+        // Policy refusals must not pin the cursor; operational errors retry this candidate.
+        if (!(error instanceof SponsoredTransactions.PeriodSpendLimitError)) {
+          result.errors++
+          stopped = true
+          break
+        }
+      }
+      lastProcessed = match.position
+    }
+
+    const remaining = await SponsoredTransactions.listRecoveryWindows(db, { failedSince })
+    const complete =
+      (!stopped && candidates.length < candidateCap) ||
+      !remaining.some((window) => window.chainId === chainId)
+    await SponsorshipReconciliationCursors.save(db, {
+      ...cursor,
+      ...lastProcessed,
+      complete: complete || (!lastProcessed && cursor.complete),
+      retryCount: complete ? 0 : retryCount,
+      retryKey: complete ? null : retryKey,
+    })
   }
 
   return result
@@ -205,9 +353,9 @@ export async function reconcile(db: Db.Db, options: reconcile.Options): Promise<
 export declare namespace reconcile {
   /** Options for {@link reconcile}. */
   type Options = {
-    /** Maximum intents considered per pass. @default 100 */
+    /** Maximum active intents considered per pass. @default 100 */
     batchSize?: number | undefined
-    /** Maximum on-chain candidates fetched per chain per pass. @default 500 */
+    /** Maximum candidates per chain in each active or recovery scan. @default 500 */
     candidateCap?: number | undefined
     /** How long failed intents remain reconciliation candidates. @default 24 hours */
     failedIntentTtlMs?: number | undefined
@@ -229,7 +377,7 @@ export declare namespace reconcile {
 
   /** Counters returned by one reconciliation pass. */
   type Result = {
-    /** Dependency or candidate errors that prevented reconciliation work. */
+    /** Dependency errors, invalid candidates, or incomplete active scans. */
     errors: number
     /** Intents matched to an on-chain transaction. */
     matched: number
@@ -238,6 +386,28 @@ export declare namespace reconcile {
   }
 }
 
+/** Reads a candidate's stable TIDX keyset position. */
+function candidatePosition(candidate: globalThis.Record<string, unknown>) {
+  const blockNumber = Value.toIntegerString(candidate['block_num'])
+  const transactionIndex = Value.toNumber(candidate['idx'])
+  if (
+    blockNumber === undefined ||
+    transactionIndex === undefined ||
+    !Number.isInteger(transactionIndex) ||
+    transactionIndex < 0
+  )
+    return undefined
+  return { blockNumber, transactionIndex }
+}
+
+/** Formats a timestamp for TIDX's ClickHouse `DateTime64` comparisons. */
+function formatTidxTimestamp(value: number) {
+  return new Date(value)
+    .toISOString()
+    .replace('T', ' ')
+    .replace(/\.\d+Z$/, '')
+}
+
 /**
  * Fetches a mined transaction's canonical envelope bytes.
  * `eth_getRawTransactionByHash` is a node extension absent from viem's typed
@@ -264,15 +434,13 @@ function getRawTransaction(client: Client, hash: Hex.Hex) {
  * runs one {@link finalize} pass, with memoized per-chain clients.
  */
 export function createFinalizer(options: createFinalizer.Options): createFinalizer.Finalizer {
-  const clients = new Map<number, Viem.getClient.ReturnType>()
-  const getClient = (chainId: number) => {
-    let client = clients.get(chainId)
-    if (!client) {
-      client = Viem.getClient({ chainId: chainId as Viem.ChainId, rpc: options.rpc })
-      clients.set(chainId, client)
-    }
-    return client
-  }
+  const zones = new Map((options.zones ?? []).map((zone) => [zone.id, zone]))
+  const chainIds = Zones.chainIds({ sourceId: Viem.chainId.mainnet, zones: zones.values() })
+  const getClient = Viem.createGetClient({
+    defaultChainId: options.defaultChainId,
+    rpc: options.rpc,
+    zones: options.zones,
+  })
   const getTidx = options.tidx
     ? Tidx.createGetClient({ defaultChainId: options.defaultChainId, tidx: options.tidx })
     : undefined
@@ -290,13 +458,67 @@ export function createFinalizer(options: createFinalizer.Options): createFinaliz
               batchSize: options.batchSize,
               feePayer,
               getClient,
-              getTidx: (chainId) => getTidx(chainId as Viem.ChainId),
+              getTidx: (chainId) => getTidx(chainId as Viem.ChainId, { zone: zones.get(chainId) }),
               limitFor: async (intent) => {
-                if (!intent.billable || !Viem.isMainnet(intent.chainId)) return undefined
+                if (!Viem.isMainnet(zones.get(intent.chainId)?.sourceId ?? intent.chainId))
+                  return undefined
+                if (!intent.billable) {
+                  if (intent.sponsorshipAttributionId) {
+                    const attribution = await SponsorshipAttributions.get(db, {
+                      id: intent.sponsorshipAttributionId,
+                      orgId: intent.orgId,
+                    })
+                    // Missing promotion state cannot prove the intent remains within Tempo's budget.
+                    if (!attribution)
+                      return {
+                        sponsorshipAttributionId: intent.sponsorshipAttributionId,
+                        billable: false,
+                        chainIds,
+                        max: -1n,
+                        since: intent.createdAt,
+                      }
+                    if (attribution.startsAt === null)
+                      return {
+                        sponsorshipAttributionId: intent.sponsorshipAttributionId,
+                        billable: false,
+                        chainIds,
+                        max: -1n,
+                        since: intent.createdAt,
+                      }
+                    if (attribution.spendLimit === null) return undefined
+                    return {
+                      billable: false,
+                      chainIds,
+                      max: BigInt(attribution.spendLimit),
+                      since: attribution.startsAt,
+                      sponsorshipAttributionId: intent.sponsorshipAttributionId,
+                    }
+                  }
+                  if (!intent.projectId) return undefined
+                  const project = await Projects.get(db, intent.projectId)
+                  // Rows recorded before canonical attribution retain their project-scoped cap.
+                  if (!project || project.sponsorshipSubsidyStartsAt === null)
+                    return {
+                      billable: false,
+                      chainIds,
+                      max: -1n,
+                      projectId: intent.projectId,
+                      since: intent.createdAt,
+                    }
+                  if (project.sponsorshipSpendLimit === null) return undefined
+                  return {
+                    billable: false,
+                    chainIds,
+                    max: BigInt(project.sponsorshipSpendLimit),
+                    projectId: intent.projectId,
+                    since: project.sponsorshipSubsidyStartsAt,
+                  }
+                }
+                if (!intent.billable) return undefined
                 const settings = await BillingSettings.get(db, intent.orgId)
                 if (settings?.spendLimit == null) return undefined
                 return {
-                  chainIds: [Viem.chainId.mainnet],
+                  chainIds,
                   max: Billing.toBaseUnits(settings.spendLimit),
                   since: Billing.periodStart(settings.period),
                 }
@@ -331,6 +553,8 @@ export declare namespace createFinalizer {
     rpc?: Viem.getClient.Rpc | undefined
     /** TIDX query client options for intent reconciliation; omit to skip reconciliation. */
     tidx?: Tidx.getClient.Tidx | undefined
+    /** Zone chains used to resolve internal receipt-lookup endpoints. */
+    zones?: Viem.createGetClient.Options['zones'] | undefined
   }
 
   /** A scheduled sponsorship finalizer. */

package/src/apps/relay/Sponsorships.zone.test.ts

@@ -0,0 +1,102 @@
+import { Hash } from 'ox'
+import { TxEnvelopeTempo } from 'ox/tempo'
+
+import * as TestApp from '../../../test/App.js'
+import * as Runtime from '../../../test/runtime.js'
+import * as Tempo from '../../../test/Tempo.js'
+import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
+import type * as Viem from '../../internal/Viem.js'
+import * as Sponsorships from './Sponsorships.js'
+
+describe('createFinalizer', () => {
+  test.each(['pending', 'failed'] as const)(
+    'passes Zone metadata to the indexer resolver for %s fill intents',
+    async (status) => {
+      const db = TestApp.database()
+      const chainId = Runtime.get().zone.chainId
+      const zone = TestApp.zone({
+        chainId,
+        rpcUrl: Runtime.get().zone.internalRpcUrl,
+        tidxUrl: 'http://127.0.0.1:9',
+      })
+      const transaction = await Tempo.accounts[0].signTransaction({
+        calls: [{ data: '0x', to: Tempo.accounts[1].address }],
+        chainId,
+        feePayer: true,
+        gas: 100_000n,
+        maxFeePerGas: 1_000_000n,
+        maxPriorityFeePerGas: 0n,
+        nonce: 0,
+      })
+      const intent = await SponsoredTransactions.upsert(db, {
+        apiKeyId: 'key_zone',
+        billable: true,
+        chainId,
+        environment: 'production',
+        orgId: 'org_zone',
+        signPayload: TxEnvelopeTempo.getFeePayerSignPayload(
+          TxEnvelopeTempo.deserialize(transaction as TxEnvelopeTempo.Serialized),
+          { sender: Tempo.accounts[0].address },
+        ),
+        transaction,
+      })
+      if (status === 'failed')
+        await SponsoredTransactions.fail(db, intent.id, new Date().toISOString())
+      const contexts: Viem.resolveRpc.Context[] = []
+      const finalizer = Sponsorships.createFinalizer({
+        db,
+        feePayer: Tempo.accounts[1].address,
+        tidx: (context) => {
+          contexts.push(context)
+          // An unavailable indexer must leave both active and failed intents retryable.
+          return { baseUrl: 'http://127.0.0.1:9' }
+        },
+        zones: [zone],
+      })
+
+      expect(await finalizer.tick()).toMatchObject({ errors: 1, matched: 0 })
+      expect(contexts).toContainEqual({ chainId, principal: null, zone })
+      expect(await SponsoredTransactions.get(db, intent.id)).toMatchObject({
+        status,
+        transactionHash: null,
+      })
+    },
+  )
+
+  test('looks up Zone receipts using configured Zone metadata', async () => {
+    const db = TestApp.database()
+    const runtime = Runtime.get()
+    const chainId = runtime.zone.chainId
+    const transaction = await Tempo.accounts[0].signTransaction({
+      calls: [{ data: '0x', to: Tempo.accounts[1].address }],
+      chainId,
+      feePayer: true,
+      gas: 100_000n,
+      maxFeePerGas: 1_000_000n,
+      maxPriorityFeePerGas: 0n,
+      nonce: 0,
+    })
+    await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_mpp_zone',
+      billable: true,
+      chainId,
+      environment: 'production',
+      orgId: 'org_mpp_zone',
+      signPayload: TxEnvelopeTempo.getFeePayerSignPayload(
+        TxEnvelopeTempo.deserialize(transaction as TxEnvelopeTempo.Serialized),
+        { sender: Tempo.accounts[0].address },
+      ),
+      transaction,
+      transactionHash: Hash.keccak256(transaction),
+    })
+    const finalizer = Sponsorships.createFinalizer({
+      db,
+      rpc: ({ zone }) => {
+        expect(zone?.id).toBe(chainId)
+        return {}
+      },
+      zones: [TestApp.zone({ chainId, rpcUrl: runtime.zone.internalRpcUrl })],
+    })
+    expect(await finalizer.tick()).toMatchObject({ errors: 0, failed: 0, finalized: 0, pending: 1 })
+  })
+})

package/src/apps/{funding → routes}/Access.ts

@@ -1,26 +1,26 @@
 import type { Context } from 'hono'
 
 import type * as App from '../../App.js'
-import type * as FundingTransfers from '../../db/tables/fundingTransfers.js'
+import type * as RoutesTransfers from '../../db/tables/routesTransfers.js'
 import * as Auth from '../../internal/Auth.js'
 import * as Response from '../../internal/Response.js'
 
-/** Returns the funding owner encoded by an API-key principal. */
-export function owner(c: Context<App.Environment>): FundingTransfers.Owner | null {
+/** Returns the routes owner encoded by an API-key principal. */
+export function owner(c: Context<App.Environment>): RoutesTransfers.Owner | null {
   const principal = Auth.getPrincipal(c)
   if (principal?.type !== 'api_key') return null
   return {
     environment: principal.environment,
     orgId: principal.orgId,
-    projectId: principal.projectId,
+    ...(principal.projectId === undefined ? {} : { projectId: principal.projectId }),
   }
 }
 
-/** Returns the error used when a funding resource has no API-key owner. */
+/** Returns the error used when a route resource has no API-key owner. */
 export function unauthorized(c: Context<App.Environment>) {
   return Response.error(c, {
     code: 'unauthorized',
-    message: 'Tempo could not determine which organization owns this funding resource.',
+    message: 'Tempo could not determine which organization owns this route resource.',
     status: 401,
   })
 }