tapimo 0.10.1 → 0.10.2

package/src/apps/funding/routes/deposit-addresses.ts

@@ -126,6 +126,27 @@ export namespace schema {
     export const Response = DepositAddress
   }
 
+  /** Schemas for the listFundingDepositAddresses operation. */
+  export namespace listFundingDepositAddresses {
+    /** Query parameters for listing funding deposit addresses. */
+    export const Query = z
+      .object({
+        cursor: Schema.Cursor,
+        limit: Schema.Limit,
+      })
+      .check(z.describe('Paging parameters for listing funding deposit addresses.'))
+
+    /** One page of reusable funding deposit addresses. */
+    export const Response = z
+      .object({
+        data: z
+          .array(DepositAddress)
+          .check(z.describe('Funding deposit addresses on this page, newest first.')),
+        nextCursor: Schema.NextCursor,
+      })
+      .check(z.describe('A page of reusable funding deposit addresses.'))
+  }
+
   /** Schemas for the reconcileFundingDepositAddress operation. */
   export namespace reconcileFundingDepositAddress {
     /** Path parameters for reconciling a funding deposit address. */
@@ -144,32 +165,49 @@ export namespace schema {
             z.meta({ examples: ['TJRabPrwbZy45sbavfcjinPJC18kjpRTv8'] }),
           ),
         cursor: Schema.Cursor,
+        destinationToken: z
+          .optional(z.string().check(z.minLength(1)))
+          .check(
+            z.describe('Destination token symbol, contract address, or token key.'),
+            z.meta({ examples: ['usdt0'] }),
+          ),
+        include: Schema.totalCountInclude,
         limit: Schema.Limit,
+        provider: z
+          .optional(z.string().check(z.minLength(1)))
+          .check(z.describe('Funding provider id.'), z.meta({ examples: ['relay'] })),
         recipient: z
           .optional(Schema.Address)
           .check(
             z.describe('Tempo account that received the deposits.'),
             z.meta({ examples: [`0x${'11'.repeat(20)}`] }),
           ),
+        sourceChain: z
+          .optional(z.string().check(z.minLength(1)))
+          .check(
+            z.describe('Source chain CAIP-2 id, slug, or alias.'),
+            z.meta({ examples: ['tron'] }),
+          ),
+        sourceToken: z
+          .optional(z.string().check(z.minLength(1)))
+          .check(
+            z.describe('Source token symbol, contract address, or token key.'),
+            z.meta({ examples: ['usdt'] }),
+          ),
+        status: z.optional(FundingDeposit.schema.Status),
       })
-      .check(
-        z.refine(
-          (query) => (query.depositAddress === undefined) !== (query.recipient === undefined),
-          {
-            error: 'Pass exactly one of `depositAddress` or `recipient`.',
-            path: ['depositAddress'],
-          },
-        ),
-        z.describe('Exactly one deposit filter and optional paging parameters.'),
-      )
+      .check(z.describe('Optional deposit filters and paging parameters.'))
 
     /** One page of detected deposits. */
     export const Response = z
       .object({
         data: z.array(Deposit).check(z.describe('Detected deposits on this page, newest first.')),
+        meta: z
+          .optional(Schema.CountMeta)
+          .check(z.describe('Extra response metadata requested with `include`.')),
         nextCursor: Schema.NextCursor,
       })
-      .check(z.describe('A page of funding deposits matching the selected filter.'))
+      .check(z.describe('A page of visible funding deposits.'))
   }
 
   /** Schemas for the getFundingDeposit operation. */
@@ -276,9 +314,114 @@ const fundingDepositExample = {
 
 const fundingDepositsExample = {
   data: [fundingDepositExample],
+  meta: { totalCount: 1, totalCountCapped: false },
   nextCursor: null,
 } satisfies z.output<typeof schema.listFundingDeposits.Response>
 
+const fundingDepositAddressesExample = {
+  data: [fundingDepositAddressExample],
+  nextCursor: null,
+} satisfies z.output<typeof schema.listFundingDepositAddresses.Response>
+
+function resolveDepositFilters(options: resolveDepositFilters.Options): FundingDeposits.Filters {
+  const { catalog, parameters } = options
+  return {
+    ...(parameters.depositAddress === undefined
+      ? {}
+      : { depositAddress: parameters.depositAddress }),
+    ...(parameters.destinationToken === undefined
+      ? {}
+      : {
+          destinationTokenKeys: resolveTokenKeys({
+            catalog,
+            input: parameters.destinationToken,
+            side: 'destination',
+          }),
+        }),
+    ...(parameters.provider === undefined
+      ? {}
+      : { providerId: parameters.provider.trim().toLowerCase() }),
+    ...(parameters.recipient === undefined ? {} : { recipient: parameters.recipient }),
+    ...(parameters.sourceChain === undefined
+      ? {}
+      : { sourceChainIds: resolveChainIds(catalog, parameters.sourceChain) }),
+    ...(parameters.sourceToken === undefined
+      ? {}
+      : {
+          sourceTokenKeys: resolveTokenKeys({
+            catalog,
+            input: parameters.sourceToken,
+            side: 'source',
+          }),
+        }),
+    ...(parameters.status === undefined ? {} : { status: parameters.status }),
+  }
+}
+
+declare namespace resolveDepositFilters {
+  type Options = {
+    catalog?: FundingCatalog.Snapshot | undefined
+    parameters: z.output<typeof schema.listFundingDeposits.Query>
+  }
+}
+
+function resolveChainIds(catalog: FundingCatalog.Snapshot | undefined, input: string): string[] {
+  const trimmed = input.trim()
+  const chain = catalog?.chainsByKey.get(trimmed.toLowerCase())
+  if (chain) return [chain.id]
+  return /^[a-z][a-z0-9-]*:.+$/i.test(trimmed) ? [trimmed] : []
+}
+
+function resolveTokenKeys(options: resolveTokenKeys.Options): string[] {
+  const trimmed = options.input.trim()
+  const normalized = trimmed.toLowerCase()
+  const keys =
+    options.catalog?.routes
+      .map((entry) => entry.route[options.side])
+      .filter((token) => matchesToken(token, trimmed, normalized))
+      .map(tokenKey) ?? []
+  if (keys.length) return [...new Set(keys)]
+  if (!/^[a-z][a-z0-9-]*:.+\/(?:erc20|trc20|token):.+$/i.test(trimmed)) return []
+  return [/\/erc20:/i.test(trimmed) ? normalized : trimmed]
+}
+
+declare namespace resolveTokenKeys {
+  type Options = {
+    catalog?: FundingCatalog.Snapshot | undefined
+    input: string
+    side: 'destination' | 'source'
+  }
+}
+
+type ResolvedToken = FundingCatalog.Snapshot['routes'][number]['route']['source']
+
+function matchesToken(token: ResolvedToken, trimmed: string, normalized: string): boolean {
+  return (
+    token.slug === normalized ||
+    token.symbol.toLowerCase() === normalized ||
+    matchesTokenIdentifier(token, token.address, trimmed, normalized) ||
+    matchesTokenIdentifier(token, tokenKey(token), trimmed, normalized)
+  )
+}
+
+function matchesTokenIdentifier(
+  token: ResolvedToken,
+  candidate: string,
+  trimmed: string,
+  normalized: string,
+): boolean {
+  return token.chain.kind === 'evm' ? candidate.toLowerCase() === normalized : candidate === trimmed
+}
+
+function tokenKey(token: ResolvedToken): string {
+  const namespace = (() => {
+    if (token.chain.kind === 'solana') return 'token'
+    if (token.chain.kind === 'tron') return 'trc20'
+    return 'erc20'
+  })()
+  return `${token.chain.id}/${namespace}:${token.address}`
+}
+
 const reconcileFundingDepositAddressResponses = (() => {
   const responses = OpenApi.responses({
     errors: {
@@ -646,6 +789,72 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         }
       },
     )
+    .get(
+      '/v1/funding/deposit-addresses',
+      Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
+      OpenApi.validate('query', schema.listFundingDepositAddresses.Query, {
+        code: 'query_invalid',
+        message: 'Check the query parameters and try again.',
+      }),
+      OpenApi.describeRoute({
+        description: 'Lists reusable funding deposit addresses, newest first.',
+        operationId: 'listFundingDepositAddresses',
+        responses: OpenApi.responses({
+          errors: {
+            400: { codes: ['query_invalid'] },
+          },
+          success: {
+            description: 'A page of reusable funding deposit addresses.',
+            example: fundingDepositAddressesExample,
+            schema: schema.listFundingDepositAddresses.Response,
+          },
+        }),
+        summary: 'List deposit addresses',
+        tags: ['Deposit Addresses'],
+      }),
+      async (c) => {
+        if (Auth.narrowAccess) return Auth.accessError(c)
+        if (OpenApi.narrowValidation)
+          return OpenApi.validationError(c, {
+            code: 'query_invalid',
+            message: 'Check the query parameters and try again.',
+          })
+
+        const owner = Access.owner(c)
+        if (!owner) return Access.unauthorized(c)
+
+        const db = Db.get(c.get('db'))
+        const { cursor, limit } = c.req.valid('query')
+        const decoded = cursor ? Cursor.decode(cursor, ['timestamp', 'id']) : undefined
+        try {
+          const rows = await FundingDepositAddresses.list(db, {
+            ...(decoded
+              ? { cursor: { createdAt: String(decoded[0]), id: String(decoded[1]) } }
+              : {}),
+            limit: limit + 1,
+            owner,
+          })
+          const page = Cursor.paginate({
+            key: (record) => [record.createdAt, record.id],
+            limit,
+            rows,
+          })
+          const data = page.rows.map(FundingDepositAddress.toPublic)
+
+          c.header('Cache-Control', Cache.policies.noStore)
+          c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key, X-API-Key')
+          return c.json(
+            Response.validated(schema.listFundingDepositAddresses.Response, {
+              data,
+              nextCursor: page.nextCursor,
+            }),
+            200,
+          )
+        } catch (cause) {
+          return Response.upstream(c, cause)
+        }
+      },
+    )
     .get(
       '/v1/funding/deposit-addresses/:id{fda_[A-Za-z0-9_-]+}',
       Auth.policy({ apiKey: { scopes: ['funding:read'] } }),
@@ -782,14 +991,14 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         message: 'Check the query parameters and try again.',
       }),
       OpenApi.describeRoute({
-        description: 'Lists deposits by deposit address or Tempo recipient, newest first.',
+        description: 'Lists visible deposits, optionally filtered, newest first.',
         operationId: 'listFundingDeposits',
         responses: OpenApi.responses({
           errors: {
             400: { codes: ['query_invalid'] },
           },
           success: {
-            description: 'A page of funding deposits matching the selected filter.',
+            description: 'A page of visible funding deposits.',
             example: fundingDepositsExample,
             schema: schema.listFundingDeposits.Response,
           },
@@ -809,32 +1018,59 @@ export function depositAddresses(options: depositAddresses.Options = {}) {
         if (!owner) return Access.unauthorized(c)
 
         const db = Db.get(c.get('db'))
-        const { cursor, depositAddress, limit, recipient } = c.req.valid('query')
+        const parameters = c.req.valid('query')
+        const { cursor, include, limit } = parameters
         const decoded = cursor ? Cursor.decode(cursor, ['timestamp', 'id']) : undefined
         try {
+          const catalog =
+            parameters.destinationToken !== undefined ||
+            parameters.sourceChain !== undefined ||
+            parameters.sourceToken !== undefined
+              ? await FundingCatalog.snapshot(c)
+              : undefined
+          const filters = resolveDepositFilters({ catalog, parameters })
+          // Counts are best-effort and share every ownership and filter predicate
+          // with the page query. A failure omits `meta` rather than failing the page.
+          const countPromise = include.includes('totalCount')
+            ? FundingDeposits.count(db, {
+                ...filters,
+                cap: Schema.countCap,
+                owner,
+              }).catch(() => {
+                c.set('fundingDepositCountFailed', true)
+                return undefined
+              })
+            : undefined
           const paging = {
+            ...filters,
             ...(decoded
               ? { cursor: { createdAt: String(decoded[0]), id: String(decoded[1]) } }
               : {}),
             limit: limit + 1,
             owner,
           }
-          const rows =
-            depositAddress === undefined
-              ? await FundingDeposits.listByRecipient(db, { ...paging, recipient: recipient! })
-              : await FundingDeposits.listByDepositAddress(db, { ...paging, depositAddress })
+          const rows = await FundingDeposits.list(db, paging)
           const page = Cursor.paginate({
             key: (record) => [record.createdAt, record.id],
             limit,
             rows,
           })
           const data = page.rows.map(FundingDeposit.toPublic)
+          const count = await countPromise
 
           c.header('Cache-Control', Cache.policies.noStore)
           c.header('Vary', 'Accept-Encoding, Authorization, Tempo-API-Key')
           return c.json(
             Response.validated(schema.listFundingDeposits.Response, {
               data,
+              ...(count === undefined
+                ? {}
+                : {
+                    meta: {
+                      totalCount: Math.min(count, Schema.countCap),
+                      totalCountCapped: count > Schema.countCap,
+                    },
+                  }),
               nextCursor: page.nextCursor,
             }),
             200,

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

@@ -841,6 +841,7 @@ describe('funding transfers OpenAPI', () => {
       deposit: summarize(spec.paths[depositPath]!.get!),
       depositAddress: summarize(spec.paths[depositAddressPath]!.get!),
       depositAddressCreate: summarize(spec.paths['/v1/funding/deposit-addresses']!.post!),
+      depositAddressList: summarize(spec.paths['/v1/funding/deposit-addresses']!.get!),
       depositAddressReconcile: summarize(spec.paths[reconcilePath]!.post!),
       deposits: summarize(spec.paths['/v1/funding/deposits']!.get!),
       detail: summarize(spec.paths[detailPath]!.get!),
@@ -889,12 +890,16 @@ describe('funding transfers OpenAPI', () => {
             "description": "Creates or returns a reusable deposit address for funding a Tempo account.",
             "summary": "Create deposit address",
           },
+          "depositAddressList": {
+            "description": "Lists reusable funding deposit addresses, newest first.",
+            "summary": "List deposit addresses",
+          },
           "depositAddressReconcile": {
             "description": "Queues an immediate provider reconciliation for one reusable funding deposit address.",
             "summary": "Reconcile deposit address",
           },
           "deposits": {
-            "description": "Lists deposits by deposit address or Tempo recipient, newest first.",
+            "description": "Lists visible deposits, optionally filtered, newest first.",
             "summary": "List deposits",
           },
           "detail": {
@@ -926,6 +931,7 @@ describe('funding transfers OpenAPI', () => {
           "Get quotes",
           "Get chains",
           "Get providers",
+          "List deposit addresses",
           "Create deposit address",
           "List transfers",
           "Create transfer",
@@ -1087,7 +1093,11 @@ describe('funding transfers OpenAPI', () => {
     const operation = spec.paths['/v1/funding/transfers']!.get
     const fields = Object.keys(operation.responses['200']!.content['application/json']!.example.data[0]!) // prettier-ignore
     expect(fields).toEqual([...fields].sort())
-    for (const route of [operation, spec.paths['/v1/funding/deposits']!.get])
+    for (const route of [
+      operation,
+      spec.paths['/v1/funding/deposit-addresses']!.get,
+      spec.paths['/v1/funding/deposits']!.get,
+    ])
       for (const parameter of route.parameters ?? [])
         expect(parameter.example ?? parameter.schema?.examples, parameter.name).toBeDefined()
   })
@@ -1126,6 +1136,9 @@ describe('funding transfers OpenAPI', () => {
       depositAddressCreate: spec.paths['/v1/funding/deposit-addresses']?.post?.operationId,
       depositAddressCreateScopes:
         spec.paths['/v1/funding/deposit-addresses']?.post?.['x-required-scopes'],
+      depositAddressList: spec.paths['/v1/funding/deposit-addresses']?.get.operationId,
+      depositAddressListScopes:
+        spec.paths['/v1/funding/deposit-addresses']?.get['x-required-scopes'],
       depositAddressReconcile: reconcilePath && spec.paths[reconcilePath]?.post?.operationId,
       depositAddressReconcileScopes:
         reconcilePath && spec.paths[reconcilePath]?.post?.['x-required-scopes'],
@@ -1150,6 +1163,8 @@ describe('funding transfers OpenAPI', () => {
       depositAddress: 'getFundingDepositAddress',
       depositAddressCreate: 'createFundingDepositAddress',
       depositAddressCreateScopes: ['funding:write'],
+      depositAddressList: 'listFundingDepositAddresses',
+      depositAddressListScopes: ['funding:read'],
       depositAddressReconcile: 'reconcileFundingDepositAddress',
       depositAddressReconcileScopes: ['funding:write'],
       depositAddressScopes: ['funding:read'],

package/src/db/Db.ts

@@ -1362,6 +1362,42 @@ export const migrations: readonly Migration[] = [
         sql`DELETE FROM webhook_queue_events WHERE status = 'pending' AND attempting_at IS NULL AND expires_at <= to_char(now() AT TIME ZONE 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`,
       ),
   },
+  {
+    name: '0123_funding_deposit_addresses_owner_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposit_addresses_owner_list_idx')
+        .ifNotExists()
+        .on('fundingDepositAddresses')
+        .columns(['orgId', 'environment', 'createdAt', 'id']),
+  },
+  {
+    name: '0124_funding_deposit_addresses_project_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposit_addresses_project_list_idx')
+        .ifNotExists()
+        .on('fundingDepositAddresses')
+        .columns(['orgId', 'environment', 'projectId', 'createdAt', 'id']),
+  },
+  {
+    name: '0125_funding_deposits_owner_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposits_owner_list_idx')
+        .ifNotExists()
+        .on('fundingDeposits')
+        .columns(['orgId', 'environment', 'createdAt', 'id']),
+  },
+  {
+    name: '0126_funding_deposits_project_list_index',
+    up: (db) =>
+      db.schema
+        .createIndex('funding_deposits_project_list_idx')
+        .ifNotExists()
+        .on('fundingDeposits')
+        .columns(['orgId', 'environment', 'projectId', 'createdAt', 'id']),
+  },
 ]
 
 /**

package/src/db/tables/fundingDepositAddresses.test.ts

@@ -578,3 +578,31 @@ describe('renewPoll', () => {
     `)
   })
 })
+
+describe('list', () => {
+  test('pages organization addresses and narrows project-attributed owners', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_address_list' } as const
+    const first = await seed({ orgId: listOwner.orgId })
+    const project = await seed({ orgId: listOwner.orgId, projectId: 'prj_address_list' })
+    const sibling = await seed({ orgId: listOwner.orgId, projectId: 'prj_address_sibling' })
+    await seed({ orgId: 'org_address_list_foreign' })
+    await seed({ environment: 'sandbox', orgId: listOwner.orgId })
+
+    const page = await FundingDepositAddresses.list(db, { limit: 2, owner: listOwner })
+    expect(page.map((record) => record.id)).toEqual([sibling.id, project.id])
+    const rest = await FundingDepositAddresses.list(db, {
+      cursor: { createdAt: project.createdAt, id: project.id },
+      limit: 2,
+      owner: listOwner,
+    })
+    expect(rest.map((record) => record.id)).toEqual([first.id])
+    expect(
+      (
+        await FundingDepositAddresses.list(db, {
+          limit: 10,
+          owner: { ...listOwner, projectId: 'prj_address_list' },
+        })
+      ).map((record) => record.id),
+    ).toEqual([project.id])
+  })
+})

package/src/db/tables/fundingDepositAddresses.ts

@@ -148,6 +148,45 @@ export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record |
   return query.executeTakeFirst()
 }
 
+/** Lists owner-visible funding deposit addresses newest-first. */
+export function list(db: Db.Db, options: list.Options): Promise<Record[]> {
+  const { cursor, limit, owner } = options
+  let query = db.kysely
+    .selectFrom('funding_deposit_addresses')
+    .selectAll()
+    .where('environment', '=', owner.environment)
+    .where('orgId', '=', owner.orgId)
+  if (owner.projectId !== undefined) query = query.where('projectId', '=', owner.projectId)
+  if (cursor)
+    query = query.where((eb) =>
+      eb.or([
+        eb('createdAt', '<', cursor.createdAt),
+        eb.and([eb('createdAt', '=', cursor.createdAt), eb('id', '<', cursor.id)]),
+      ]),
+    )
+  return query.orderBy('createdAt', 'desc').orderBy('id', 'desc').limit(limit).execute()
+}
+
+export declare namespace list {
+  /** Ownership and paging options for funding deposit addresses. */
+  type Options = {
+    /** Exclusive lower bound from the previous page. */
+    cursor?: Cursor | undefined
+    /** Maximum rows to return. */
+    limit: number
+    /** Ownership filter derived from the authenticated API key. */
+    owner: Owner
+  }
+
+  /** Cursor fields for the last address returned by the previous page. */
+  type Cursor = {
+    /** Deposit address creation time. */
+    createdAt: string
+    /** Deposit address id, used as a deterministic tie-breaker. */
+    id: string
+  }
+}
+
 /** Gets the reusable address that matches one owner and route identity. */
 export function getMatching(db: Db.Db, match: Match): Promise<Record | undefined> {
   let query = db.kysely

package/src/db/tables/fundingDeposits.test.ts

@@ -498,3 +498,85 @@ describe('toPublic', () => {
     })
   })
 })
+
+describe('list', () => {
+  test('pages organization deposits and narrows project-attributed owners', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_deposit_list' } as const
+    const firstAddress = await seedAddress({ orgId: listOwner.orgId })
+    const projectAddress = await seedAddress({
+      orgId: listOwner.orgId,
+      projectId: 'prj_deposit_list',
+    })
+    const siblingAddress = await seedAddress({
+      orgId: listOwner.orgId,
+      projectId: 'prj_deposit_sibling',
+    })
+    const first = await seedDeposit(firstAddress)
+    const project = await seedDeposit(projectAddress)
+    const sibling = await seedDeposit(siblingAddress)
+    const foreignAddress = await seedAddress({ orgId: 'org_deposit_list_foreign' })
+    await seedDeposit(foreignAddress)
+    const sandboxAddress = await seedAddress({
+      environment: 'sandbox',
+      orgId: listOwner.orgId,
+    })
+    await seedDeposit(sandboxAddress)
+
+    const page = await FundingDeposits.list(db, { limit: 2, owner: listOwner })
+    expect(page.map((record) => record.id)).toEqual([sibling.id, project.id])
+    const rest = await FundingDeposits.list(db, {
+      cursor: { createdAt: project.createdAt, id: project.id },
+      limit: 2,
+      owner: listOwner,
+    })
+    expect(rest.map((record) => record.id)).toEqual([first.id])
+    expect(
+      (
+        await FundingDeposits.list(db, {
+          limit: 10,
+          owner: { ...listOwner, projectId: 'prj_deposit_list' },
+        })
+      ).map((record) => record.id),
+    ).toEqual([project.id])
+  })
+
+  test('AND-combines filters and counts through the same ownership scope', async () => {
+    const listOwner = { environment: owner.environment, orgId: 'org_deposit_filters' } as const
+    const recipient = `0x${'ab'.repeat(20)}`
+    const address = await seedAddress({
+      orgId: listOwner.orgId,
+      snapshot: TestFunding.depositAddressSnapshot({
+        provider: { id: 'relay_filters', name: 'Relay' },
+        recipient,
+      }),
+    })
+    const match = await seedDeposit(address)
+    const unrelatedAddress = await seedAddress({ orgId: listOwner.orgId })
+    await seedDeposit(unrelatedAddress)
+    const filters = {
+      depositAddress: address.address,
+      destinationTokenKeys: [address.destinationTokenKey],
+      providerId: address.providerId,
+      recipient: recipient.toLowerCase(),
+      sourceChainIds: [address.sourceChainId],
+      sourceTokenKeys: [address.sourceTokenKey],
+      status: 'detected',
+    } as const
+
+    expect(
+      (await FundingDeposits.list(db, { ...filters, limit: 10, owner: listOwner })).map(
+        (record) => record.id,
+      ),
+    ).toEqual([match.id])
+    expect(await FundingDeposits.count(db, { ...filters, cap: 10, owner: listOwner })).toBe(1)
+    expect(await FundingDeposits.count(db, { ...filters, cap: 0, owner: listOwner })).toBe(1)
+    expect(
+      await FundingDeposits.count(db, {
+        ...filters,
+        destinationTokenKeys: [],
+        cap: 10,
+        owner: listOwner,
+      }),
+    ).toBe(0)
+  })
+})