tapimo 0.5.1 → 0.5.2

package/src/apps/data/FundingQuoteProviders.test.ts

@@ -22,6 +22,22 @@ describe('FundingQuoteProviders', () => {
     })
   })
 
+  test('requires every Squid deployment binding when any is configured', () => {
+    expect(FundingQuoteProviders.configureSquid()).toBeUndefined()
+    expect(() =>
+      FundingQuoteProviders.configureSquid({ integratorId: 'squid-integrator-id' }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+    expect(
+      FundingQuoteProviders.configureSquid({
+        integratorId: 'squid-integrator-id',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toEqual({
+      integratorId: 'squid-integrator-id',
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+  })
+
   test('maps successful Across quotes to available quote probes', async () => {
     const requests: RecordedRequest[] = []
     const candidate = quoteCandidate('across')
@@ -172,6 +188,80 @@ describe('FundingQuoteProviders', () => {
     })
   })
 
+  test('maps successful Squid quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('squid')
+    const fetch = recordingFetch(requests, async () => jsonResponse(squidQuote(candidate)))
+    const adapter = FundingQuoteProviders.squid({
+      baseUrl: 'https://squid.test/v2/',
+      fetch,
+      integratorId: 'squid-integrator-id',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/v2/route')
+    expect(new Headers(requests[0]?.init?.headers).get('x-integrator-id')).toBe(
+      'squid-integrator-id',
+    )
+    expect(jsonRequestBody(requests[0])).toEqual({
+      fromAddress: '0x1111111111111111111111111111111111111111',
+      fromAmount: '1000000',
+      fromChain: '8453',
+      fromToken: candidate.sourceToken.address,
+      quoteOnly: true,
+      slippage: 1,
+      toAddress: '0x1111111111111111111111111111111111111111',
+      toChain: '4217',
+      toToken: candidate.destinationToken.address,
+    })
+    expect(result).toEqual({
+      minimumOutputAmount: '989622',
+      outputAmount: '999620',
+      outputAmountFormatted: '0.99962',
+      quality: {
+        estimatedSeconds: 10,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'squid:route-v2',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps unavailable Squid routes to unavailable quote probes', async () => {
+    const candidate = quoteCandidate('squid')
+    const adapter = FundingQuoteProviders.squid({
+      fetch: recordingFetch([], async () =>
+        jsonResponse(
+          {
+            message: 'Please increase the swap amount and try again.',
+            statusCode: 400,
+            type: 'BAD_REQUEST',
+          },
+          400,
+        ),
+      ),
+      integratorId: 'squid-integrator-id',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        sourceDetail: 'squid:route-v2:AMOUNT_TOO_LOW',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
   test('maps successful Rhino quotes to available quote probes', async () => {
     const requests: RecordedRequest[] = []
     const candidate = quoteCandidate('rhino')
@@ -437,6 +527,64 @@ describe('FundingQuoteProviders', () => {
       ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
     })
 
+  const invalidSquidQuotes = [
+    [
+      'mismatched input amounts',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromAmount = '1'),
+    ],
+    [
+      'mismatched input token addresses',
+      (body: ReturnType<typeof squidQuote>) =>
+        (body.route.estimate.fromToken.address = '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2'),
+    ],
+    [
+      'mismatched input chains',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromToken.chainId = 1),
+    ],
+    [
+      'mismatched input decimals',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromToken.decimals = 18),
+    ],
+    [
+      'mismatched output token addresses',
+      (body: ReturnType<typeof squidQuote>) =>
+        (body.route.estimate.toToken.address = '0x20c00000000000000000000014f22ca97301eb73'),
+    ],
+    [
+      'mismatched output chains',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toToken.chainId = '1'),
+    ],
+    [
+      'mismatched output decimals',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toToken.decimals = 18 as never),
+    ],
+    [
+      'zero output amounts',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toAmount = '0'),
+    ],
+    [
+      'invalid output bounds',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toAmountMin = '1000000'),
+    ],
+  ] as const
+
+  for (const [name, mutate] of invalidSquidQuotes)
+    test(`rejects Squid quotes with ${name}`, async () => {
+      const candidate = quoteCandidate('squid')
+      const body = squidQuote(candidate)
+      mutate(body)
+      const adapter = FundingQuoteProviders.squid({
+        fetch: recordingFetch([], async () => jsonResponse(body)),
+        integratorId: 'squid-integrator-id',
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+
+      await expect(
+        adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+    })
+
   test('returns bounded Across failure diagnostics', async () => {
     const candidate = quoteCandidate('across')
     const adapter = FundingQuoteProviders.across({
@@ -473,6 +621,19 @@ describe('FundingQuoteProviders', () => {
       operation: 'swap/approval',
     })
   })
+
+  test('returns bounded Squid failure diagnostics', () => {
+    expect(
+      FundingQuoteProviders.providerFailure({
+        cause: new TypeError('network failure'),
+        provider: 'squid',
+      }),
+    ).toEqual({
+      failure: 'network',
+      id: 'squid',
+      operation: 'v2/route',
+    })
+  })
 })
 
 type RecordedRequest = {
@@ -527,6 +688,29 @@ function acrossQuote(candidate: FundingQuotes.QuoteProbeInput['candidate']) {
   }
 }
 
+function squidQuote(candidate: FundingQuotes.QuoteProbeInput['candidate']) {
+  return {
+    route: {
+      estimate: {
+        estimatedRouteDuration: 10,
+        fromAmount: candidate.sourceAmount.amount,
+        fromToken: {
+          address: candidate.sourceToken.address,
+          chainId: 8453,
+          decimals: candidate.sourceToken.decimals,
+        },
+        toAmount: '999620',
+        toAmountMin: '989622',
+        toToken: {
+          address: candidate.destinationToken.address,
+          chainId: '4217',
+          decimals: candidate.destinationToken.decimals,
+        },
+      },
+    },
+  }
+}
+
 function probeInput(
   candidate: FundingQuotes.QuoteProbeInput['candidate'],
 ): FundingQuotes.QuoteProbeInput {

package/src/apps/data/FundingQuoteProviders.ts

@@ -9,10 +9,12 @@ const defaultFetch: Fetch = (input, init) => globalThis.fetch(input, init)
 const defaultAcrossBaseUrl = 'https://app.across.to/api'
 const defaultRelayBaseUrl = 'https://api.relay.link'
 const defaultRhinoBaseUrl = 'https://api.rhino.fi/bridge'
+const defaultSquidBaseUrl = 'https://v2.api.squidrouter.com/v2'
 const providerOperations = {
   across: 'swap/approval',
   relay: 'quote/v2',
   rhino: 'quote/bridge-swap/public',
+  squid: 'v2/route',
 } as const
 
 namespace schema {
@@ -44,6 +46,25 @@ namespace schema {
     receiveAmount: z.string().check(z.regex(/^\d+(\.\d+)?$/)),
     token: z.string(),
   })
+
+  const SquidToken = z.object({
+    address: z.string(),
+    chainId: z.union([z.string(), z.number().check(z.int(), z.nonnegative())]),
+    decimals: z.number().check(z.int(), z.nonnegative()),
+  })
+
+  export const SquidQuote = z.object({
+    route: z.object({
+      estimate: z.object({
+        estimatedRouteDuration: z.number().check(z.nonnegative()),
+        fromAmount: IntegerString,
+        fromToken: SquidToken,
+        toAmount: IntegerString,
+        toAmountMin: IntegerString,
+        toToken: SquidToken,
+      }),
+    }),
+  })
 }
 
 /** Creates the live funding quote adapters configured for this deployment. */
@@ -52,6 +73,7 @@ export function createAdapters(options: createAdapters.Options = {}) {
     ...(options.across ? { across: across(options.across) } : {}),
     ...(options.relay ? { relay: relay(options.relay) } : {}),
     ...(options.rhino ? { rhino: rhino(options.rhino) } : {}),
+    ...(options.squid ? { squid: squid(options.squid) } : {}),
   } satisfies FundingQuotes.ProviderAdapters
 }
 
@@ -64,6 +86,8 @@ export declare namespace createAdapters {
     relay?: relay.Options | false | undefined
     /** Rhino quote adapter options. */
     rhino?: rhino.Options | false | undefined
+    /** Squid quote adapter options. */
+    squid?: squid.Options | false | undefined
   }
 }
 
@@ -92,6 +116,27 @@ export declare namespace configureAcross {
   }
 }
 
+/** Resolves all-or-none Squid deployment configuration. */
+export function configureSquid(options: configureSquid.Options = {}): squid.Options | undefined {
+  const configured = [options.integratorId, options.userAddress].filter(Boolean)
+  if (configured.length === 0) return undefined
+  if (!options.integratorId || !options.userAddress) throw new ProviderConfigurationError()
+  return {
+    integratorId: options.integratorId,
+    userAddress: options.userAddress,
+  }
+}
+
+export declare namespace configureSquid {
+  /** Optional deployment bindings required together to enable Squid. */
+  type Options = {
+    /** Squid integrator id binding. */
+    integratorId?: string | undefined
+    /** Squid quote-user binding. */
+    userAddress?: string | undefined
+  }
+}
+
 /** Creates an Across quote adapter backed by `/swap/approval`. */
 export function across(options: across.Options): FundingQuotes.ProviderAdapter {
   assertAcrossConfiguration(options)
@@ -284,6 +329,74 @@ export declare namespace rhino {
   }
 }
 
+/** Creates a Squid quote adapter backed by `/v2/route`. */
+export function squid(options: squid.Options): FundingQuotes.ProviderAdapter {
+  assertSquidConfiguration(options)
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultSquidBaseUrl)
+  const fetcher = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+
+  return {
+    async probeQuote({ candidate }, signal) {
+      const fromChain = eip155ChainId(candidate.sourceChain)
+      const toChain = eip155ChainId(candidate.destinationChain)
+
+      try {
+        const quote = await requestJson(new URL(`${baseUrl}/route`), {
+          body: {
+            fromAddress: options.userAddress,
+            fromAmount: candidate.sourceAmount.amount,
+            fromChain,
+            fromToken: candidate.sourceToken.address,
+            quoteOnly: true,
+            // V1 quotes use a fixed 1% tolerance; callers cannot customize execution policy.
+            slippage: 1,
+            toAddress: options.userAddress,
+            toChain,
+            toToken: candidate.destinationToken.address,
+          },
+          fetcher,
+          headers: { 'x-integrator-id': options.integratorId },
+          method: 'POST',
+          signal,
+        })
+        return formatSquidResult(candidate, quote, now())
+      } catch (cause) {
+        const unavailable =
+          providerUnavailable(cause, [
+            'NO_ROUTE',
+            'NO_ROUTE_FOUND',
+            'ROUTE_NOT_FOUND',
+            'UNSUPPORTED_ROUTE',
+          ]) ?? squidUnavailable(cause)
+        if (!unavailable) throw cause
+        return unavailableResult({
+          detail: 'squid:route-v2',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  }
+}
+
+export declare namespace squid {
+  /** Squid quote adapter options. */
+  type Options = {
+    /** Override for tests or Squid test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: Fetch | undefined
+    /** Squid integrator id sent in the required request header. */
+    integratorId: string
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+    /** Probe wallet address used as the Squid sender and recipient. */
+    userAddress: string
+  }
+}
+
 /** Returns bounded provider failure details suitable for structured request logs. */
 export function providerFailure(options: providerFailure.Options): providerFailure.Result {
   const operation = providerOperations[options.provider]
@@ -436,6 +549,42 @@ function formatRhinoResult(
   }
 }
 
+function formatSquidResult(
+  candidate: FundingQuotes.QuoteCandidate,
+  quote: unknown,
+  now: Date,
+): FundingQuotes.QuoteProbeResult {
+  const parsed = schema.SquidQuote.safeParse(quote)
+  if (!parsed.success) throw new ProviderPayloadError()
+  const response = parsed.data.route.estimate
+  if (
+    response.fromAmount !== candidate.sourceAmount.amount ||
+    !matchesSquidToken(response.fromToken, candidate.sourceChain, candidate.sourceToken) ||
+    !matchesSquidToken(response.toToken, candidate.destinationChain, candidate.destinationToken) ||
+    BigInt(response.toAmount) <= 0n ||
+    BigInt(response.toAmountMin) <= 0n ||
+    BigInt(response.toAmountMin) > BigInt(response.toAmount)
+  )
+    throw new ProviderPayloadError()
+
+  return {
+    minimumOutputAmount: response.toAmountMin,
+    outputAmount: response.toAmount,
+    outputAmountFormatted: decimalFromBaseUnits(
+      response.toAmount,
+      candidate.destinationToken.decimals,
+    ),
+    quality: {
+      estimatedSeconds: Math.ceil(response.estimatedRouteDuration),
+      liquiditySource: 'providerQuote',
+      sourceDetail: 'squid:route-v2',
+      tier: 'liquid',
+    },
+    sampledAt: now.toISOString(),
+    status: 'available',
+  }
+}
+
 function unavailableResult(options: {
   detail: string
   message: string
@@ -492,11 +641,29 @@ function providerUnavailable(cause: unknown, codes: readonly string[]) {
 
 function providerErrorCode(input: unknown) {
   const body = record(input)
+  const error = record(body['error'])
   const code =
-    stringValue(body['_tag']) ?? stringValue(body['code']) ?? stringValue(body['errorCode'])
+    stringValue(body['_tag']) ??
+    stringValue(body['code']) ??
+    stringValue(body['errorCode']) ??
+    stringValue(body['errorType']) ??
+    stringValue(body['type']) ??
+    stringValue(error['code']) ??
+    stringValue(error['type'])
   return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined
 }
 
+function squidUnavailable(cause: unknown) {
+  if (!(cause instanceof ProviderResponseError) || cause.status !== 400) return undefined
+  const body = record(cause.body)
+  if (
+    body['type'] === 'BAD_REQUEST' &&
+    body['message'] === 'Please increase the swap amount and try again.'
+  )
+    return 'AMOUNT_TOO_LOW'
+  return undefined
+}
+
 function providerChainId(
   quoteChain: FundingQuotes.QuoteCandidate['sourceChain'],
   provider: string,
@@ -539,6 +706,18 @@ function matchesToken(
   )
 }
 
+function matchesSquidToken(
+  token: z.output<typeof schema.SquidQuote>['route']['estimate']['fromToken'],
+  chain: FundingQuotes.ChainRef,
+  expected: FundingQuotes.TokenRef,
+) {
+  return (
+    token.address.toLowerCase() === expected.address.toLowerCase() &&
+    String(token.chainId) === eip155ChainId(chain) &&
+    token.decimals === expected.decimals
+  )
+}
+
 function eip155ChainId(chain: { id: string; kind: string }) {
   if (chain.kind !== 'evm') throw new UnsupportedProviderChainError()
   const match = /^eip155:(\d+)$/.exec(chain.id)
@@ -605,6 +784,11 @@ function assertAcrossConfiguration(options: across.Options) {
     throw new ProviderConfigurationError()
 }
 
+function assertSquidConfiguration(options: squid.Options) {
+  if (options.integratorId.length === 0 || !/^0x[\da-fA-F]{40}$/.test(options.userAddress))
+    throw new ProviderConfigurationError()
+}
+
 class ProviderConfigurationError extends Error {
   override name = 'FundingQuoteProviders.ProviderConfigurationError'
 }

package/src/apps/data/routes/funding.test.ts

@@ -299,6 +299,13 @@ describe('GET /funding/providers', () => {
         requiresApiKey: false,
         status: 'unconfigured',
       },
+      {
+        id: 'squid',
+        kind: 'solverNetwork',
+        name: 'Squid',
+        requiresApiKey: true,
+        status: 'unconfigured',
+      },
     ])
   })
 

package/src/apps/data/routes/funding.ts

@@ -118,7 +118,7 @@ export namespace schema {
   export const ProviderRef = Schema.describe(
     z.object({
       id: z
-        .enum(['across', 'relay', 'rhino'])
+        .enum(['across', 'relay', 'rhino', 'squid'])
         .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
       kind: z
         .string()
@@ -237,7 +237,7 @@ export namespace schema {
   export const Provider = Schema.describe(
     z.object({
       id: z
-        .enum(['across', 'relay', 'rhino'])
+        .enum(['across', 'relay', 'rhino', 'squid'])
         .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
       kind: z
         .string()
@@ -285,10 +285,10 @@ export namespace schema {
             z.meta({ examples: ['USDC.e'] }),
           ),
         provider: z
-          .optional(z.enum(['across', 'relay', 'rhino']))
+          .optional(z.enum(['across', 'relay', 'rhino', 'squid']))
           .check(
             z.describe(
-              'Only request a quote from this provider. Supported ids are `across`, `relay`, and `rhino`; omit it to query every configured provider.',
+              'Only request a quote from this provider. Supported ids are `across`, `relay`, `rhino`, and `squid`; omit it to query every configured provider.',
             ),
             z.meta({ examples: ['relay'] }),
           ),

package/src/apps/data/routes/tokens.test.ts

@@ -272,6 +272,60 @@ describe('GET /tokens?verified=true', () => {
 })
 
 describe('GET /tokens?addresses=', () => {
+  test('separates repeated addresses in the response cache', async () => {
+    const routed = TestApp.create({ db })
+    const headers = { authorization: `Bearer ${TestApp.key.token}` }
+    const repeated = new URLSearchParams()
+    repeated.append('addresses', TestApp.token)
+    repeated.append('addresses', TestApp.tokenWithHolders)
+    const single = new URLSearchParams({
+      addresses: TestApp.tokenWithHolders,
+    })
+
+    const primed = await routed.request(`/v1/tokens?${repeated}`, { headers })
+    const miss = await routed.request(`/v1/tokens?${single}`, { headers })
+    const hit = await routed.request(`/v1/tokens?${single}`, { headers })
+    const primedBody = await TestApp.json(primed, Tokens.schema.getTokens.Response)
+    const body = await TestApp.json(hit, Tokens.schema.getTokens.Response)
+
+    expect(primed.status).toBe(200)
+    expect(miss.status).toBe(200)
+    expect(hit.status).toBe(200)
+    expect(primedBody.data.map((token) => token.address)).toEqual([
+      TestApp.token,
+      TestApp.tokenWithHolders,
+    ])
+    expect(miss.headers.has('RateLimit-Limit')).toBe(true)
+    expect(hit.headers.has('RateLimit-Limit')).toBe(false)
+    expect(body.data.map((token) => token.address)).toEqual([TestApp.tokenWithHolders])
+  })
+
+  test('separates repeated includes in the response cache', async () => {
+    const routed = TestApp.create({ db })
+    const headers = { authorization: `Bearer ${TestApp.key.token}` }
+    const repeated = new URLSearchParams({ limit: '5' })
+    repeated.append('include', 'createdAt')
+    repeated.append('include', 'holderCount')
+    const single = new URLSearchParams({
+      include: 'holderCount',
+      limit: '5',
+    })
+
+    const primed = await routed.request(`/v1/tokens?${repeated}`, { headers })
+    const miss = await routed.request(`/v1/tokens?${single}`, { headers })
+    const hit = await routed.request(`/v1/tokens?${single}`, { headers })
+    const primedBody = await TestApp.json(primed, Tokens.schema.getTokens.Response)
+    const body = await TestApp.json(hit, Tokens.schema.getTokens.Response)
+
+    expect(primed.status).toBe(200)
+    expect(miss.status).toBe(200)
+    expect(hit.status).toBe(200)
+    expect(primedBody.data.every((token) => typeof token.createdAt === 'string')).toBe(true)
+    expect(miss.headers.has('RateLimit-Limit')).toBe(true)
+    expect(hit.headers.has('RateLimit-Limit')).toBe(false)
+    expect(body.data.every((token) => token.createdAt === undefined)).toBe(true)
+  })
+
   test('returns the requested tokens as a single page in input order', async () => {
     const client = app()
     const response = await client.v1.tokens.$get(

package/src/apps/data/routes/transfers.test.ts

@@ -271,7 +271,24 @@ describe('GET /transfers', () => {
     },
   )
 
-  test('embeds a capped total count on demand via include=totalCount', async () => {
+  test('embeds a capped unscoped total count on demand', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { include: 'totalCount', limit: '5' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(true)
+    expect(body.meta).toBeDefined()
+    expect(Number.isInteger(body.meta?.totalCount)).toBe(true)
+    expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    expect(body.meta!.totalCount).toBeLessThanOrEqual(Schema.countCap)
+    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount >= Schema.countCap)
+  })
+
+  test('embeds a capped token-scoped total count on demand', async () => {
     const client = TestApp.client()
 
     if (Runtime.get().mode === 'localnet') expect(TestApp.token).toBeDefined()
@@ -350,6 +367,61 @@ describe('GET /transfers', () => {
     },
   )
 
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'counts unscoped cross-token transfers',
+    async () => {
+      const crossToken = Runtime.get().fixtures?.crossTokenTransfer
+      expect(crossToken).toBeDefined()
+      if (!crossToken) return
+
+      const client = TestApp.client()
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            address: crossToken.sender,
+            include: 'crossToken,totalCount',
+            limit: '50',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(response.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(true)
+      expect(body.data.some((entry) => entry.transactionHash === crossToken.hash)).toBe(true)
+      expect(body.meta).toBeDefined()
+      expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    },
+  )
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'counts token-scoped cross-token transfers',
+    async () => {
+      const crossToken = Runtime.get().fixtures?.crossTokenTransfer
+      expect(crossToken).toBeDefined()
+      if (!crossToken) return
+
+      const client = TestApp.client()
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            include: 'crossToken,totalCount',
+            limit: '50',
+            token: crossToken.destinationToken,
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(response.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(true)
+      expect(body.meta).toBeDefined()
+      expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    },
+  )
+
   test('surfaces a 502 when transfer data is unavailable', async () => {
     // Point at an unreachable indexer so the upstream query fails deterministically.
     const client = TestApp.client({ tidx: { baseUrl: 'http://127.0.0.1:1' } })