tapimo 0.12.0 → 0.14.0

package/src/Client.test-d.ts

@@ -3,6 +3,7 @@ import { Mpp as PublicMpp } from 'tapimo/mpp'
 import type * as z from 'zod/mini'
 
 import * as Activities from './apps/data/routes/activities.js'
+import * as ApiKeys from './apps/management/routes/api-keys.js'
 import * as Balances from './apps/data/routes/balances.js'
 import * as Billing from './apps/management/routes/billing.js'
 import * as Blocks from './apps/data/routes/blocks.js'
@@ -82,6 +83,50 @@ test('returns typed client', async () => {
 })
 
 describe('narrows responses by status', () => {
+  test('POST /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId/rotate', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].rotate.$post({
+      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.rotateApiKey.Response>>()
+    }
+  })
+
+  test('POST /v1/orgs/:orgId/api-keys/:keyId/rotate', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'][
+      ':keyId{key_[A-Za-z0-9_-]+}'
+    ].rotate.$post({ param: { keyId: 'key_test', orgId: 'org_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.rotateApiKey.Response>>()
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/api-keys/:keyId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'][
+      ':keyId{key_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { keyId: 'key_test', orgId: 'org_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 429 | 502>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.revokeApiKey.Response>>()
+    }
+  })
+
   test('POST /v1/mpp/validate', async () => {
     const client = Client.create()
     const res = await client.v1.mpp.validate.$post({ json: mppInput })
@@ -196,6 +241,9 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.capabilities?.deposit).toEqualTypeOf<boolean | undefined>()
       expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
       expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.data[0]!.instantLiquidityValue).toEqualTypeOf<
+        VaultValue | null | undefined
+      >()
       expectTypeOf(json.data[0]!.sharePrice?.amount).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string | null>()
       expectTypeOf(json.data[0]!.state.openRedeemRequestCount).toEqualTypeOf<number>()
@@ -271,7 +319,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.earn.addresses[':address'].positions.$get({
       param: { address: `0x${'bb'.repeat(20)}` },
-      query: { 'valuation.currency': 'USD', verified: 'true' },
+      query: { include: 'earnings', 'valuation.currency': 'USD', verified: 'true' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -286,6 +334,13 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.assetToken.address).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.data[0]!.assetToken.decimals).toEqualTypeOf<number>()
       expectTypeOf(json.data[0]!.id).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.data[0]!.lifetimeCashFlows?.status).toEqualTypeOf<
+        'complete' | 'incomplete_history' | undefined
+      >()
+      if (json.data[0]!.lifetimeCashFlows?.status === 'complete') {
+        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalDeposited).toEqualTypeOf<string>()
+        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalWithdrawn).toEqualTypeOf<string>()
+      }
       expectTypeOf(json.data[0]!.shareAmount.amount).toEqualTypeOf<string>()
       expectTypeOf(json.data[0]!.shareAmount.decimals).toEqualTypeOf<number>()
       expectTypeOf(json.data[0]!.shareAmount.formatted).toEqualTypeOf<string>()
@@ -336,6 +391,7 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.assetToken.address).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
       expectTypeOf(json.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.instantLiquidityValue).toEqualTypeOf<VaultValue | null | undefined>()
       expectTypeOf(json.label).toEqualTypeOf<string>()
       expectTypeOf(json.meta?.valuation?.asOf).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.sharePrice?.decimals).toEqualTypeOf<number | undefined>()
@@ -374,6 +430,7 @@ describe('narrows responses by status', () => {
         address: `0x${'bb'.repeat(20)}`,
         vaultId: `0x${'aa'.repeat(20)}`,
       },
+      query: { asOf: '2026-07-21T09:00:00.000Z' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
@@ -385,6 +442,9 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.assetAllowance).toEqualTypeOf<string>()
       expectTypeOf(json.assetBalance).toEqualTypeOf<string>()
       expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.asOf).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.block?.number).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.block?.timestamp).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.shareAllowance).toEqualTypeOf<string>()
       expectTypeOf(json.shareBalance).toEqualTypeOf<string>()
@@ -442,7 +502,23 @@ describe('narrows responses by status', () => {
       if (json.status === 'complete' && json.period === 'active')
         expectTypeOf(json.activeEarnings).toEqualTypeOf<string>()
       if (json.status === 'complete' && json.period === 'lifetime')
-        expectTypeOf(json.lifetimeEarnings).toEqualTypeOf<string>()
+        expectTypeOf({
+          lifetimeEarnings: json.lifetimeEarnings,
+          totalDeposited: json.totalDeposited,
+          totalWithdrawn: json.totalWithdrawn,
+        }).toEqualTypeOf<{
+          lifetimeEarnings: string
+          totalDeposited: string
+          totalWithdrawn: string
+        }>()
+      if (json.status === 'pending_redemption' && json.period === 'lifetime')
+        expectTypeOf({
+          totalDeposited: json.totalDeposited,
+          totalWithdrawn: json.totalWithdrawn,
+        }).toEqualTypeOf<{
+          totalDeposited: string
+          totalWithdrawn: string
+        }>()
       if (json.status === 'complete' && json.period === '30d')
         expectTypeOf(json.windowEarnings).toEqualTypeOf<string>()
       void json
@@ -2563,6 +2639,7 @@ describe('narrows responses by status', () => {
       amount: '1000000',
       destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
       mode: 'exactSource',
+      provider: 'stargate',
       recipient: `0x${'11'.repeat(20)}`,
       sender: `0x${'22'.repeat(20)}`,
       sourceChain: 'eip155:8453',
@@ -2692,6 +2769,42 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('POST /v1/funding/transfers/:id/source-transactions', async () => {
+    const client = Client.create()
+    const res = await client.v1.funding.transfers[':id{ftr_[A-Za-z0-9_-]+}'][
+      'source-transactions'
+    ].$post({
+      json: { transactionHash: `0x${'51'.repeat(32)}` },
+      param: { id: 'ftr_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 501 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.sourceTransactionHashes).toEqualTypeOf<string[] | undefined>()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<
+            typeof FundingTransfers.schema.registerFundingTransferSourceTransaction.Response
+          >['status']
+        >()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          | 'funding_transfer_not_awaiting_source'
+          | 'source_transaction_conflict'
+          | 'source_transaction_pending'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
   test('GET /v1/exchange/swaps', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.swaps.$get()
@@ -3611,6 +3724,16 @@ describe('narrows responses by status', () => {
         },
       },
     })
+    void client.v1.webhooks.$post({
+      json: {
+        destination: { type: 'url', url: 'https://example.com/webhook' },
+        eventType: 'funding:transfer.updated',
+        filters: {
+          id: 'ftr_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
+          status: 'completed',
+        },
+      },
+    })
     const res = await client.v1.webhooks.$post({
       json: {
         destination: { type: 'url', url: 'https://example.com/webhook' },
@@ -3902,6 +4025,10 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.envelope.data.status).toEqualTypeOf<
           z.output<typeof Webhooks.schema.FundingDepositEvent>['status']
         >()
+      if (json.envelope.type === 'funding:transfer.updated')
+        expectTypeOf(json.envelope.data.status).toEqualTypeOf<
+          z.output<typeof Webhooks.schema.FundingTransferEvent>['status']
+        >()
       expectTypeOf(json.requestUrl).toEqualTypeOf<string>()
       void json
     }

package/src/Scope.test.ts

@@ -52,3 +52,23 @@ describe('extend', () => {
     ).toThrowErrorMatchingInlineSnapshot(`[Error: Duplicate scope \`data:read\`.]`)
   })
 })
+
+describe('expandAliases', () => {
+  test('adds the current scope for a legacy Zone read scope', () => {
+    expect(
+      Scope.expandAliases(['data:read', 'zone:1424310001:read', 'zone:1424310001:write']),
+    ).toEqual([
+      'data:read',
+      'zone:1424310001:read',
+      'zone:1424310001:write',
+      'zone:1424310003:read',
+    ])
+  })
+
+  test('does not duplicate an existing current scope', () => {
+    expect(Scope.expandAliases(['zone:1424310001:read', 'zone:1424310003:read'])).toEqual([
+      'zone:1424310001:read',
+      'zone:1424310003:read',
+    ])
+  })
+})

package/src/Scope.ts

@@ -6,6 +6,8 @@
 
 import * as z from 'zod/mini'
 
+import * as Schema from './internal/Schema.js'
+
 /**
  * Wildcard scope. A key whose `scopes` contains this value satisfies every
  * required scope, so it never needs re-provisioning when new scopes are added.
@@ -154,6 +156,20 @@ export function includes(catalog: Catalog, scope: string): scope is Id {
   return schema.Zone.safeParse(scope).success || catalog.some((entry) => entry.scope === scope)
 }
 
+/** Adds current read scopes granted by legacy Zone read scopes. */
+export function expandAliases(scopes: readonly string[]): readonly string[] {
+  const aliases = new Set<string>()
+  for (const scope of scopes) {
+    const match = /^zone:([1-9]\d*):read$/.exec(scope)
+    if (!match) continue
+    const chainId = Number(match[1])
+    const resolved = Schema.resolveChainId(chainId)
+    if (resolved !== chainId) aliases.add(`zone:${resolved}:read`)
+  }
+  for (const scope of scopes) aliases.delete(scope)
+  return aliases.size ? [...scopes, ...aliases] : scopes
+}
+
 /** Returns the self-issuable identifiers in a scope catalog. */
 export function selfServeFrom(catalog: Catalog): readonly Id[] {
   return catalog

package/src/Webhooks.ts

@@ -5,6 +5,6 @@ export * from './internal/Webhooks.js'
 
 // Re-export the webhook resource's zod schemas so consumers can validate and
 // type delivery bodies: `Webhooks.schema.Envelope` (a discriminated union on
-// `type`), plus the per-event `TransferEvent` / `TransactionEvent` / `PingEvent`
-// payloads. Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
+// `type`), plus the per-event payload schemas such as `FundingTransferEvent`.
+// Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
 export { enrichEventData, eventTypes, scanBlock, schema } from './apps/data/routes/webhooks.js'

package/src/admin/apps/api-keys.test.ts

@@ -299,6 +299,81 @@ describe('DELETE /api-keys/:id', () => {
   })
 })
 
+describe('POST /api-keys/:id/rotate', () => {
+  test('mints a replacement with the source access and attribution', async () => {
+    const { client, store } = await setup()
+    const { record: source, token: sourceToken } = await core_ApiKeys.mint(store, {
+      allowedIps: ['203.0.113.0/24'],
+      billingActive: true,
+      createdBy: 'customer@example.com',
+      environment: 'sandbox',
+      expiresAt: '2100-01-01T00:00:00.000Z',
+      name: 'Privy Zones',
+      orgId: 'org_privy',
+      projectId: 'prj_privy',
+      rateLimits: { '*': { limit: 10_000, period: 'minute' } },
+      scopes: ['zone:421700001:read', 'zone:421700001:write'],
+    })
+
+    const response = await client['api-keys'][':id'].rotate.$post({
+      param: { id: source.id },
+    })
+    const body = await TestApp.json(response, ApiKeys.schema.rotateApiKey.Response)
+
+    expect(response.status).toBe(200)
+    expect(body).toMatchObject({
+      allowedIps: source.allowedIps,
+      billingActive: source.billingActive,
+      createdBy: TestAdmin.identity.email,
+      environment: source.environment,
+      expiresAt: source.expiresAt,
+      name: source.name,
+      orgId: source.orgId,
+      projectId: source.projectId,
+      rateLimits: source.rateLimits,
+      scopes: source.scopes,
+    })
+    expect(body.id).not.toBe(source.id)
+    expect(body.token).not.toBe(sourceToken)
+    expect(await core_ApiKeys.resolve(store, sourceToken)).not.toBeNull()
+    expect(await core_ApiKeys.resolve(store, body.token)).toMatchObject({
+      id: body.id,
+      scopes: source.scopes,
+    })
+  })
+
+  test('unknown id → 404', async () => {
+    const { client } = await setup()
+    const response = await client['api-keys'][':id'].rotate.$post({
+      param: { id: 'key_missing' },
+    })
+
+    expect(response.status).toMatchInlineSnapshot(`404`)
+  })
+
+  test('keeps a rotated one-off key assignable to an organization', async () => {
+    const { client, db, store } = await setup()
+    const organization = await Organizations.create(db, { name: 'Tempo' })
+    const { record: source } = await core_ApiKeys.mint(store, {
+      name: 'One-off',
+      scopes: ['data:read'],
+    })
+
+    const rotateResponse = await client['api-keys'][':id'].rotate.$post({
+      param: { id: source.id },
+    })
+    const replacement = await TestApp.json(rotateResponse, ApiKeys.schema.rotateApiKey.Response)
+    expect(replacement.orgId).toBe(replacement.id)
+
+    const updateResponse = await client['api-keys'][':id'].$patch({
+      json: { orgId: organization.id },
+      param: { id: replacement.id },
+    })
+    expect(updateResponse.status).toBe(200)
+    expect((await core_ApiKeys.get(store, replacement.id))?.orgId).toBe(organization.id)
+  })
+})
+
 describe('PATCH /api-keys/:id', () => {
   test('preserves the allowlist when omitted', async () => {
     const { client, store } = TestAdmin.setup()

package/src/admin/apps/api-keys.ts

@@ -173,6 +173,24 @@ export namespace schema {
       .object({ id: z.string().check(z.describe('Revoked key id.')) })
       .check(z.describe('API-key revocation result.'))
   }
+
+  /** Schemas for the rotateApiKey operation. */
+  export namespace rotateApiKey {
+    /** Path parameters for rotating a key. */
+    export const Params = z
+      .object({
+        id: z
+          .string()
+          .check(
+            z.describe('Stable id of the key to rotate.'),
+            z.meta({ examples: ['key_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
+          ),
+      })
+      .check(z.describe('Path parameters for rotating an API key.'))
+
+    /** Response: the replacement record plus its one-time plaintext token. */
+    export const Response = createApiKey.Response
+  }
 }
 
 /**
@@ -183,6 +201,7 @@ export namespace schema {
  * - `GET /` lists key records (metadata only), optionally filtered by `orgId`.
  * - `DELETE /:id` revokes a key by id (`404` if absent).
  * - `PATCH /:id` updates a key's allowlist, name, or project, or assigns its first organization.
+ * - `POST /:id/rotate` mints a replacement with the source key's access and attribution.
  * - `POST /backfill` rebuilds the id and org index entries for every record.
  */
 export function apiKeys() {
@@ -315,6 +334,51 @@ export function apiKeys() {
         return c.json(Response.validated(schema.revokeApiKey.Response, { id }))
       },
     )
+    .post(
+      '/:id/rotate',
+      OpenApi.validate('param', schema.rotateApiKey.Params, {
+        code: 'param_invalid',
+        message: 'Invalid path parameters',
+      }),
+      OpenApi.describeRoute({
+        description: 'Create a replacement that preserves the source key access and attribution. The source key remains active.', // prettier-ignore
+        operationId: 'rotateAdminApiKey',
+        responses: OpenApi.responses({
+          errors: { 404: 'API key not found.' },
+          success: {
+            description: 'Replacement key (includes the one-time token).',
+            schema: schema.rotateApiKey.Response,
+          },
+        }),
+        summary: 'Rotate API key',
+        tags: ['API keys'],
+      }),
+      async (c) => {
+        const { id } = c.req.valid('param')
+        const store = c.get('kv').store
+        const source = await ApiKeys.get(store, id)
+        if (!source)
+          return Response.error(c, {
+            code: 'not_found',
+            message: 'API key not found.',
+            status: 404,
+          })
+
+        const { record, token } = await ApiKeys.mint(store, {
+          allowedIps: source.allowedIps,
+          createdBy: c.get('identity')!.email,
+          environment: source.environment,
+          scopes: source.scopes,
+          ...(source.billingActive === undefined ? {} : { billingActive: source.billingActive }),
+          ...(source.expiresAt === undefined ? {} : { expiresAt: source.expiresAt }),
+          ...(source.name === undefined ? {} : { name: source.name }),
+          ...(source.orgId === source.id ? {} : { orgId: source.orgId }),
+          ...(source.projectId === undefined ? {} : { projectId: source.projectId }),
+          ...(source.rateLimits === undefined ? {} : { rateLimits: source.rateLimits }),
+        })
+        return c.json(Response.validated(schema.rotateApiKey.Response, { ...record, token }), 200)
+      },
+    )
     .patch(
       '/:id',
       OpenApi.validate('param', schema.updateApiKey.Params, {

package/src/admin/apps/earn-vaults.test.ts

@@ -204,7 +204,7 @@ describe('putVerifiedEarnVault', () => {
       expect(await response.json()).toMatchObject({
         error: {
           code: 'body_invalid',
-          details: [{ message: 'Zone 1424310001 is configured more than once.' }],
+          details: [{ message: 'Zone 1424310003 is configured more than once.' }],
         },
       })
     },

package/src/admin/apps/earn-vaults.ts

@@ -94,7 +94,7 @@ export namespace schema {
           .check(z.describe('Custom vault slug, generated from the label when omitted.')),
         vaultAddress: Schema.Address.check(
           z.describe('Earn vault contract address.'),
-          z.meta({ examples: ['0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a'] }),
+          z.meta({ examples: ['0x4f94590b636f5878bce585e82379de81e1ec174f'] }),
         ),
         zones: z
           .optional(z.array(EarnVaults.schema.ZoneRoute))
@@ -510,6 +510,7 @@ async function serializeVault(
     assetToken,
     discovery: options.discovery,
     include: options.include,
+    instantLiquidityValue: null,
     record: options.record,
     shareToken,
     tvl: null,

package/src/admin/apps/organizations.test.ts

@@ -181,6 +181,7 @@ describe('GET /organizations/:orgId', () => {
       settings: { spendLimit: '1000', txFeeLimit: null },
       source: null,
     })
+    expect(body.sponsorshipSubsidy).toEqual({ durationDays: null, projectSpendLimit: null })
   })
 
   test('returns empty counts and billing for a memberless organization', async () => {
@@ -215,6 +216,57 @@ describe('GET /organizations/:orgId', () => {
   })
 })
 
+describe('PUT /organizations/:orgId/sponsorship', () => {
+  test('enables and disables a 90-day per-project policy', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Privy' })
+
+    const enabled = await client.organizations[':orgId'].sponsorship.$put({
+      json: { enabled: true, projectSpendLimit: '1000' },
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(enabled, AdminOrganizations.schema.organizationSponsorship.SetResponse),
+    ).toEqual({ durationDays: 90, projectSpendLimit: '1000' })
+
+    const disabled = await client.organizations[':orgId'].sponsorship.$put({
+      json: { enabled: false },
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(disabled, AdminOrganizations.schema.organizationSponsorship.SetResponse),
+    ).toEqual({ durationDays: null, projectSpendLimit: null })
+  })
+
+  test('enables an uncapped policy', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Privy' })
+    const response = await client.organizations[':orgId'].sponsorship.$put({
+      json: { enabled: true },
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(response, AdminOrganizations.schema.organizationSponsorship.SetResponse),
+    ).toEqual({ durationDays: 90, projectSpendLimit: null })
+  })
+
+  test('rejects invalid limits and unknown organizations', async () => {
+    const { app, client } = TestAdmin.setup()
+    const invalid = await app.request('/organizations/org_example/sponsorship', {
+      body: JSON.stringify({ enabled: true, projectSpendLimit: '-1' }),
+      headers: { 'content-type': 'application/json' },
+      method: 'PUT',
+    })
+    expect(invalid.status).toBe(400)
+
+    const missing = await client.organizations[':orgId'].sponsorship.$put({
+      json: { enabled: true, projectSpendLimit: '1000' },
+      param: { orgId: 'org_missing' },
+    })
+    expect(missing.status).toBe(404)
+  })
+})
+
 describe('PUT/DELETE /organizations/:orgId/billing-sources/:source', () => {
   test('enables and disables sources idempotently', async () => {
     const { client, db } = TestAdmin.setup()
@@ -425,7 +477,7 @@ describe('GET /organizations/:orgId/sponsorship', () => {
     })
     const body = await TestApp.json(
       response,
-      AdminOrganizations.schema.getOrganizationSponsorship.Response,
+      AdminOrganizations.schema.organizationSponsorship.GetResponse,
     )
 
     expect(body.production).toMatchObject({