@ledgerhq/coin-tezos 10.2.0 → 10.2.2

package/src/network/tzkt.test.ts

@@ -14,6 +14,7 @@ import type {
   APITokenTransfer,
   APITransactionType,
 } from './types'
+import type { DeepPartial, DeepPartialReturn } from '@ledgerhq/coin-module-framework/test/utils'
 // tzkt.ts imports `network` from "@ledgerhq/live-network" (the package root, not the /network
 // subpath). We mock the same path so Jest's module registry intercepts those calls.
 import network from '@ledgerhq/live-network'
@@ -30,7 +31,7 @@ import {
 
 jest.mock('@ledgerhq/live-network')
 jest.mock('@ledgerhq/logs')
-const mockedNetwork = jest.mocked(network)
+const mockedNetwork = jest.mocked<DeepPartialReturn<typeof network>>(network)
 const mockedLog = jest.mocked(log)
 
 // The tzkt module is NOT mocked here. `createTzktApi(config)` returns a plain object whose methods
@@ -42,7 +43,7 @@ const mockedLog = jest.mocked(log)
 // The paginated helpers (`fetchAllTransactions`, `fetchBlock*`) are top-level functions that build
 // their OWN fresh `createTzktApi(config)` instance internally, so spying on `api` cannot intercept
 // them. Those tests therefore drive the mocked `network` directly.
-const config = mockConfig as TezosCoinConfig
+const config: TezosCoinConfig = mockConfig
 const api = createTzktApi(config)
 
 // ---------------------------------------------------------------------------
@@ -51,36 +52,30 @@ const api = createTzktApi(config)
 
 /** Wraps raw data into the shape that @ledgerhq/live-network resolves with. */
 function networkResponse<T>(data: T) {
-  return Promise.resolve({
-    data,
-    status: 200,
-    headers: {} as any,
-    statusText: '',
-    config: { headers: {} as any },
-  })
+  return Promise.resolve({ data })
 }
 
-function makeApiBlock(level = 100): APIBlock {
-  return { level, hash: `BLk${level}`, timestamp: '2024-01-01T00:00:00Z' } as APIBlock
+function makeApiBlock(level = 100): Pick<APIBlock, 'level' | 'hash' | 'timestamp'> {
+  return { level, hash: `BLk${level}`, timestamp: '2024-01-01T00:00:00Z' }
 }
 
-function makeTxItem(id: number): APITransactionType {
-  return { id } as APITransactionType
+function makeTxItem(id: number): DeepPartial<APITransactionType> {
+  return { id }
 }
 
-function makeTokenItem(id: number): APITokenTransfer {
-  return { id } as APITokenTransfer
+function makeTokenItem(id: number): DeepPartial<APITokenTransfer> {
+  return { id }
 }
 
-function makeDelegationItem(id: number): APIDelegationType {
-  return { id } as APIDelegationType
+function makeDelegationItem(id: number): DeepPartial<APIDelegationType> {
+  return { id }
 }
 
-function makeStakingItem(id: number): APIStakingType {
-  return { id } as APIStakingType
+function makeStakingItem(id: number): DeepPartial<APIStakingType> {
+  return { id }
 }
 
-function makeOperation(id: number): APIOperation {
+function makeOperation(id: number): DeepPartial<APIOperation> {
   return {
     id,
     type: 'transaction',
@@ -92,15 +87,15 @@ function makeOperation(id: number): APIOperation {
     initiator: null,
     sender: null,
     target: null,
-  } as APIOperation
+  }
 }
 
-function makeTokenWithTxId(id: number, transactionId?: number): APITokenTransfer {
-  return { ...makeTokenItem(id), transactionId } as APITokenTransfer
+function makeTokenWithTxId(id: number, transactionId?: number): DeepPartial<APITokenTransfer> {
+  return { ...makeTokenItem(id), transactionId }
 }
 
-function makeTokenWithOrigId(id: number, originationId?: number): APITokenTransfer {
-  return { ...makeTokenItem(id), originationId } as APITokenTransfer
+function makeTokenWithOrigId(id: number, originationId?: number): DeepPartial<APITokenTransfer> {
+  return { ...makeTokenItem(id), originationId }
 }
 
 const localSpies: jest.SpyInstance[] = []
@@ -127,7 +122,7 @@ describe('tzkt network API', () => {
 
   describe('api.getBlockCount', () => {
     it('calls the blocks count endpoint and returns the number', async () => {
-      mockedNetwork.mockReturnValue(networkResponse(12_345) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(12_345))
 
       const result = await api.getBlockCount()
 
@@ -147,7 +142,7 @@ describe('tzkt network API', () => {
   describe('api.getLastBlock', () => {
     it('returns hash, level and date from the first block in the sorted list', async () => {
       const blocks = [makeApiBlock(9_001)]
-      mockedNetwork.mockReturnValue(networkResponse(blocks) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(blocks))
 
       const result = await api.getLastBlock()
 
@@ -171,8 +166,8 @@ describe('tzkt network API', () => {
 
   describe('api.getAccountByAddress', () => {
     it('calls the account endpoint and returns the account payload', async () => {
-      const account = { type: 'empty', address: 'tz1abc', counter: 0 } as APIAccount
-      mockedNetwork.mockReturnValue(networkResponse(account) as ReturnType<typeof network>)
+      const account: DeepPartial<APIAccount> = { type: 'empty', address: 'tz1abc', counter: 0 }
+      mockedNetwork.mockReturnValue(networkResponse(account))
 
       const result = await api.getAccountByAddress('tz1abc')
 
@@ -185,8 +180,8 @@ describe('tzkt network API', () => {
     })
 
     it('coalesces concurrent calls for the same address into a single request', async () => {
-      const account = { type: 'user', address: 'tz1dup', revealed: true } as APIAccount
-      mockedNetwork.mockReturnValue(networkResponse(account) as ReturnType<typeof network>)
+      const account: DeepPartial<APIAccount> = { type: 'user', address: 'tz1dup', revealed: true }
+      mockedNetwork.mockReturnValue(networkResponse(account))
 
       const [first, second] = await Promise.all([
         api.getAccountByAddress('tz1dup'),
@@ -205,8 +200,8 @@ describe('tzkt network API', () => {
 
   describe('api.getAccountOperations', () => {
     it('requests operations with serialized query', async () => {
-      const ops: APIOperation[] = [makeOperation(1)]
-      mockedNetwork.mockReturnValue(networkResponse(ops) as ReturnType<typeof network>)
+      const ops: DeepPartial<APIOperation>[] = [makeOperation(1)]
+      mockedNetwork.mockReturnValue(networkResponse(ops))
 
       const result = await api.getAccountOperations('tz1addr', {
         lastId: 10,
@@ -216,7 +211,7 @@ describe('tzkt network API', () => {
       })
 
       expect(result).toEqual(ops)
-      const call = mockedNetwork.mock.calls[0][0] as { url: string }
+      const call = mockedNetwork.mock.calls[0][0]
       expect(call.url).toContain('/v1/accounts/tz1addr/operations')
       expect(call.url).toContain('lastId=10')
       expect(call.url).toContain('limit=50')
@@ -225,10 +220,10 @@ describe('tzkt network API', () => {
     })
 
     it('omits undefined optional fields from the serialized query', async () => {
-      const ops: APIOperation[] = [makeOperation(1)]
-      mockedNetwork.mockReturnValue(networkResponse(ops) as ReturnType<typeof network>)
+      const ops: DeepPartial<APIOperation>[] = [makeOperation(1)]
+      mockedNetwork.mockReturnValue(networkResponse(ops))
       const query = {
-        lastId: undefined as number | undefined,
+        lastId: undefined,
         limit: 40,
         sort: 'Ascending' as const,
         'level.ge': 0,
@@ -236,7 +231,7 @@ describe('tzkt network API', () => {
 
       await api.getAccountOperations('tz1addr', query)
 
-      const call = mockedNetwork.mock.calls[0][0] as { url: string }
+      const call = mockedNetwork.mock.calls[0][0]
       expect(call.url).not.toMatch(/lastId=/)
       expect(call.url).toContain('limit=40')
     })
@@ -248,8 +243,8 @@ describe('tzkt network API', () => {
 
   describe('api.getOperationsTransactions', () => {
     it('fetches without cursor and strips undefined extra args', async () => {
-      const txs: APITransactionType[] = [makeTxItem(1)]
-      mockedNetwork.mockReturnValue(networkResponse(txs) as ReturnType<typeof network>)
+      const txs: DeepPartial<APITransactionType>[] = [makeTxItem(1)]
+      mockedNetwork.mockReturnValue(networkResponse(txs))
 
       const result = await api.getOperationsTransactions(100, undefined, {
         foo: undefined,
@@ -257,7 +252,7 @@ describe('tzkt network API', () => {
       })
 
       expect(result).toEqual(txs)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({
         'level.gte': 100,
         limit: 1000,
@@ -274,12 +269,12 @@ describe('tzkt network API', () => {
     })
 
     it('includes offset.cr when cursor is set', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getOperationsTransactions(5, 999)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(999)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 999 })
     })
   })
 
@@ -289,10 +284,10 @@ describe('tzkt network API', () => {
 
   describe('api.getOperationsOrigination', () => {
     it('fetches without cursor and strips undefined extra args', async () => {
-      const originations: (APITransactionType & { block: string; hash: string })[] = [
-        { id: 1, hash: 'h1', block: 'b1' } as APITransactionType & { hash: string; block: string },
+      const originations: DeepPartial<APITransactionType & { hash: string; block: string }>[] = [
+        { id: 1, hash: 'h1', block: 'b1' },
       ]
-      mockedNetwork.mockReturnValue(networkResponse(originations) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(originations))
 
       const result = await api.getOperationsOrigination(100, undefined, {
         foo: undefined,
@@ -300,7 +295,7 @@ describe('tzkt network API', () => {
       })
 
       expect(result).toEqual(originations)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({
         'level.gte': 100,
         limit: 1000,
@@ -317,12 +312,12 @@ describe('tzkt network API', () => {
     })
 
     it('includes offset.cr when cursor is set', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getOperationsOrigination(5, 999)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(999)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 999 })
     })
   })
 
@@ -332,8 +327,8 @@ describe('tzkt network API', () => {
 
   describe('api.getTokenTransfers', () => {
     it('passes through params and strips undefined extra args', async () => {
-      const transfers: APITokenTransfer[] = [makeTokenItem(1)]
-      mockedNetwork.mockReturnValue(networkResponse(transfers) as ReturnType<typeof network>)
+      const transfers: DeepPartial<APITokenTransfer>[] = [makeTokenItem(1)]
+      mockedNetwork.mockReturnValue(networkResponse(transfers))
 
       const result = await api.getTokenTransfers({
         'level.gte': 200,
@@ -342,7 +337,7 @@ describe('tzkt network API', () => {
       })
 
       expect(result).toEqual(transfers)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({
         'level.gte': 200,
         select: 'id',
@@ -365,12 +360,9 @@ describe('tzkt network API', () => {
       const spyTx = spyOnApi('getOperationsTransactions')
       const spyOrig = spyOnApi('getOperationsOrigination')
 
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse([
-            makeTokenWithTxId(1, undefined),
-            makeTokenWithTxId(2, undefined),
-          ]) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse([makeTokenWithTxId(1, undefined), makeTokenWithTxId(2, undefined)])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -382,10 +374,7 @@ describe('tzkt network API', () => {
       expect(spyTx).not.toHaveBeenCalled()
       expect(spyOrig).not.toHaveBeenCalled()
       expect(result).toEqual([])
-      const firstCall = mockedNetwork.mock.calls[0]?.[0] as {
-        url: string
-        params?: Record<string, unknown>
-      }
+      const firstCall = mockedNetwork.mock.calls[0]?.[0]
       expect(firstCall.params).toMatchObject({
         'level.ge': 10,
         'sort.asc': 'id',
@@ -398,20 +387,12 @@ describe('tzkt network API', () => {
     it('joins operation hashes and uses empty string when no match', async () => {
       const spyTx = spyOnApi('getOperationsTransactions')
       const spyOrig = spyOnApi('getOperationsOrigination')
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse([
-            makeTokenWithTxId(1, 100),
-            makeTokenWithTxId(2, 200),
-          ]) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse([makeTokenWithTxId(1, 100), makeTokenWithTxId(2, 200)])
         }
-        if (config.url.includes('/v1/operations/transactions')) {
-          return networkResponse([
-            { id: 100, hash: 'h100', block: 'BLK100' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+        if (config.url?.includes('/v1/operations/transactions')) {
+          return networkResponse([{ id: 100, hash: 'h100', block: 'BLK100' }])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -433,24 +414,15 @@ describe('tzkt network API', () => {
     it('attaches parent hash and block from originations when only originationIds are present', async () => {
       const spyTx = spyOnApi('getOperationsTransactions')
       const spyOrig = spyOnApi('getOperationsOrigination')
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse([
-            makeTokenWithOrigId(1, 100),
-            makeTokenWithOrigId(2, 200),
-          ]) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse([makeTokenWithOrigId(1, 100), makeTokenWithOrigId(2, 200)])
         }
-        if (config.url.includes('/v1/operations/originations')) {
+        if (config.url?.includes('/v1/operations/originations')) {
           return networkResponse([
-            { id: 100, hash: 'h100', block: 'BLK100' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-            { id: 200, hash: 'h200', block: 'BLK200' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+            { id: 100, hash: 'h100', block: 'BLK100' },
+            { id: 200, hash: 'h200', block: 'BLK200' },
+          ])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -472,28 +444,15 @@ describe('tzkt network API', () => {
     it('joins both transactions and originations when both ids are present', async () => {
       const spyTx = spyOnApi('getOperationsTransactions')
       const spyOrig = spyOnApi('getOperationsOrigination')
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse([
-            makeTokenWithTxId(1, 100),
-            makeTokenWithOrigId(2, 500),
-          ]) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse([makeTokenWithTxId(1, 100), makeTokenWithOrigId(2, 500)])
         }
-        if (config.url.includes('/v1/operations/transactions')) {
-          return networkResponse([
-            { id: 100, hash: 'hTx', block: 'BLK_TX' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+        if (config.url?.includes('/v1/operations/transactions')) {
+          return networkResponse([{ id: 100, hash: 'hTx', block: 'BLK_TX' }])
         }
-        if (config.url.includes('/v1/operations/originations')) {
-          return networkResponse([
-            { id: 500, hash: 'hOrig', block: 'BLK_ORIG' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+        if (config.url?.includes('/v1/operations/originations')) {
+          return networkResponse([{ id: 500, hash: 'hOrig', block: 'BLK_ORIG' }])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -515,29 +474,20 @@ describe('tzkt network API', () => {
     })
 
     it('keeps partial hash/block from the parent transaction without dropping transfers', async () => {
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
           return networkResponse([
             makeTokenWithTxId(1, 100),
             makeTokenWithTxId(2, 200),
             makeTokenWithTxId(3, 300),
-          ]) as ReturnType<typeof network>
+          ])
         }
-        if (config.url.includes('/v1/operations/transactions')) {
+        if (config.url?.includes('/v1/operations/transactions')) {
           return networkResponse([
-            { id: 100, hash: 'h100', block: '' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-            { id: 200, hash: '', block: 'BLK200' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-            { id: 300, hash: 'h300', block: 'BLK300' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+            { id: 100, hash: 'h100', block: '' },
+            { id: 200, hash: '', block: 'BLK200' },
+            { id: 300, hash: 'h300', block: 'BLK300' },
+          ])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -556,29 +506,20 @@ describe('tzkt network API', () => {
     })
 
     it('keeps partial hash/block from the parent origination without dropping transfers', async () => {
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
           return networkResponse([
             makeTokenWithOrigId(1, 100),
             makeTokenWithOrigId(2, 200),
             makeTokenWithOrigId(3, 300),
-          ]) as ReturnType<typeof network>
+          ])
         }
-        if (config.url.includes('/v1/operations/originations')) {
+        if (config.url?.includes('/v1/operations/originations')) {
           return networkResponse([
-            { id: 100, hash: 'h100', block: '' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-            { id: 200, hash: '', block: 'BLK200' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-            { id: 300, hash: 'h300', block: 'BLK300' } as APITransactionType & {
-              hash: string
-              block: string
-            },
-          ]) as ReturnType<typeof network>
+            { id: 100, hash: 'h100', block: '' },
+            { id: 200, hash: '', block: 'BLK200' },
+            { id: 300, hash: 'h300', block: 'BLK300' },
+          ])
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
@@ -597,7 +538,7 @@ describe('tzkt network API', () => {
     })
 
     it('uses sort.desc=id when sort is Descending and forwards level.lt / level.gt', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getAccountTokenTransfers('tz1sort', {
         sort: 'Descending',
@@ -606,7 +547,7 @@ describe('tzkt network API', () => {
         limit: 50,
       })
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({
         'sort.desc': 'id',
         'level.ge': 1,
@@ -617,7 +558,7 @@ describe('tzkt network API', () => {
     })
 
     it('forwards level.gt for ascending continuation windows', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getAccountTokenTransfers('tz1asc', {
         sort: 'Ascending',
@@ -625,7 +566,7 @@ describe('tzkt network API', () => {
         'level.gt': 500,
       })
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({
         'sort.asc': 'id',
         'level.ge': 100,
@@ -634,25 +575,28 @@ describe('tzkt network API', () => {
     })
 
     it('batches transaction id.in lookups in chunks of 100 when more than 100 ids are present', async () => {
-      const spyTx = spyOnApi('getOperationsTransactions')
-      const spyOrig = spyOnApi('getOperationsOrigination')
+      spyOnApi('getOperationsTransactions')
+      spyOnApi('getOperationsOrigination')
+      const spyTx = jest.mocked<DeepPartialReturn<typeof api.getOperationsTransactions>>(
+        api.getOperationsTransactions
+      )
+      const spyOrig = jest.mocked<DeepPartialReturn<typeof api.getOperationsOrigination>>(
+        api.getOperationsOrigination
+      )
 
       const tokens = Array.from({ length: 150 }, (_, i) => makeTokenWithTxId(i + 1, i + 1))
 
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse(tokens) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse(tokens)
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
 
       spyTx.mockImplementation(async (_level, _cursor, params) => {
-        const ids = (params?.['id.in'] as string).split(',').map(Number)
-        return ids.map((id) => ({
-          id,
-          hash: `h${id}`,
-          block: `BLK${id}`,
-        })) as (APITransactionType & { hash: string; block: string })[]
+        const idIn = params?.['id.in']
+        const ids = typeof idIn === 'string' ? idIn.split(',').map(Number) : []
+        return ids.map((id) => ({ id, hash: `h${id}`, block: `BLK${id}` }))
       })
 
       const result = await api.getAccountTokenTransfers('tz1batch', {
@@ -675,25 +619,28 @@ describe('tzkt network API', () => {
     })
 
     it('batches origination id.in lookups in chunks of 100 when more than 100 ids are present', async () => {
-      const spyTx = spyOnApi('getOperationsTransactions')
-      const spyOrig = spyOnApi('getOperationsOrigination')
+      spyOnApi('getOperationsTransactions')
+      spyOnApi('getOperationsOrigination')
+      const spyTx = jest.mocked<DeepPartialReturn<typeof api.getOperationsTransactions>>(
+        api.getOperationsTransactions
+      )
+      const spyOrig = jest.mocked<DeepPartialReturn<typeof api.getOperationsOrigination>>(
+        api.getOperationsOrigination
+      )
 
       const tokens = Array.from({ length: 150 }, (_, i) => makeTokenWithOrigId(i + 1, i + 1))
 
-      mockedNetwork.mockImplementation(async (config: { url: string }) => {
-        if (config.url.includes('/v1/tokens/transfers')) {
-          return networkResponse(tokens) as ReturnType<typeof network>
+      mockedNetwork.mockImplementation(async (config) => {
+        if (config.url?.includes('/v1/tokens/transfers')) {
+          return networkResponse(tokens)
         }
         throw new Error(`unexpected url: ${config.url}`)
       })
 
       spyOrig.mockImplementation(async (_level, _cursor, params) => {
-        const ids = (params?.['id.in'] as string).split(',').map(Number)
-        return ids.map((id) => ({
-          id,
-          hash: `h${id}`,
-          block: `BLK${id}`,
-        })) as (APITransactionType & { hash: string; block: string })[]
+        const idIn = params?.['id.in']
+        const ids = typeof idIn === 'string' ? idIn.split(',').map(Number) : []
+        return ids.map((id) => ({ id, hash: `h${id}`, block: `BLK${id}` }))
       })
 
       const result = await api.getAccountTokenTransfers('tz1batchOrig', {
@@ -722,7 +669,7 @@ describe('tzkt network API', () => {
 
   describe('api.getUnstakeRequestsFinalizable', () => {
     it('queries finalizable unstake requests and sums actualAmount', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([100, 250, 7]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([100, 250, 7]))
 
       const result = await api.getUnstakeRequestsFinalizable('tz1abc')
 
@@ -741,7 +688,7 @@ describe('tzkt network API', () => {
     })
 
     it('returns 0n when no finalizable requests exist', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await api.getUnstakeRequestsFinalizable('tz1empty')
 
@@ -775,7 +722,7 @@ describe('tzkt network API', () => {
           actualAmount: 40,
         },
       ]
-      mockedNetwork.mockReturnValue(networkResponse(fixture) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(fixture))
 
       const result = await api.getUnstakeRequests('tz1abc')
 
@@ -794,7 +741,7 @@ describe('tzkt network API', () => {
     })
 
     it('returns an empty array when no requests match', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await api.getUnstakeRequests('tz1empty')
 
@@ -808,8 +755,8 @@ describe('tzkt network API', () => {
 
   describe('api.getTokensBalances', () => {
     it('requests all FA2 balances for the account when no filter is passed', async () => {
-      const balances = [{ id: 1 } as APITokenBalance]
-      mockedNetwork.mockReturnValue(networkResponse(balances) as ReturnType<typeof network>)
+      const balances: DeepPartial<APITokenBalance>[] = [{ id: 1 }]
+      mockedNetwork.mockReturnValue(networkResponse(balances))
 
       const result = await api.getTokensBalances('tz1bal')
 
@@ -826,8 +773,8 @@ describe('tzkt network API', () => {
     })
 
     it('requests a specific FA2 contract and token id when a filter is passed', async () => {
-      const balances = [{ id: 2 } as APITokenBalance]
-      mockedNetwork.mockReturnValue(networkResponse(balances) as ReturnType<typeof network>)
+      const balances: DeepPartial<APITokenBalance>[] = [{ id: 2 }]
+      mockedNetwork.mockReturnValue(networkResponse(balances))
 
       const result = await api.getTokensBalances('tz1bal', {
         contractAddress: 'KT1abc',
@@ -859,7 +806,7 @@ describe('tzkt network API', () => {
   // `.data` is the page. The page cursor (`lastId`) is serialized into the request URL.
   describe('fetchAllTransactions', () => {
     it('returns empty when the first page is empty', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await fetchAllTransactions(config, 'tz1acc')
 
@@ -868,30 +815,30 @@ describe('tzkt network API', () => {
 
     it('concatenates pages until an empty response', async () => {
       mockedNetwork
-        .mockReturnValueOnce(networkResponse([makeOperation(1)]) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse([makeOperation(2)]) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse([]) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse([makeOperation(1)]))
+        .mockReturnValueOnce(networkResponse([makeOperation(2)]))
+        .mockReturnValueOnce(networkResponse([]))
 
       const result = await fetchAllTransactions(config, 'tz1acc')
 
       expect(result).toEqual([makeOperation(1), makeOperation(2)])
       expect(mockedNetwork).toHaveBeenCalledTimes(3)
       // First page: no cursor (lastId undefined is stripped from the query), sort ascending.
-      const firstUrl = (mockedNetwork.mock.calls[0][0] as { url: string }).url
+      const firstUrl = mockedNetwork.mock.calls[0][0].url
       expect(firstUrl).toContain('/v1/accounts/tz1acc/operations')
       expect(firstUrl).not.toMatch(/lastId=/)
       expect(firstUrl).toContain('sort=Ascending')
       expect(firstUrl).toContain('level.ge=0')
       // Second page: cursor advances to the id of the last op returned by the first page.
-      const secondUrl = (mockedNetwork.mock.calls[1][0] as { url: string }).url
+      const secondUrl = mockedNetwork.mock.calls[1][0].url
       expect(secondUrl).toContain('lastId=1')
       expect(secondUrl).toContain('sort=Ascending')
       expect(secondUrl).toContain('level.ge=0')
     })
 
     it('logs and returns when the last operation has a falsy id', async () => {
-      const opMissingId = { ...makeOperation(1), id: 0 } as APIOperation
-      mockedNetwork.mockReturnValue(networkResponse([opMissingId]) as ReturnType<typeof network>)
+      const opMissingId: DeepPartial<APIOperation> = { ...makeOperation(1), id: 0 }
+      mockedNetwork.mockReturnValue(networkResponse([opMissingId]))
 
       const result = await fetchAllTransactions(config, 'tz1acc')
 
@@ -903,9 +850,7 @@ describe('tzkt network API', () => {
       // Always return one op with a truthy id so the loop would continue without the cap. The id
       // increases every call so cursors keep advancing (matching the previous spy implementation).
       let nextId = 0
-      mockedNetwork.mockImplementation(
-        () => networkResponse([makeOperation(++nextId)]) as ReturnType<typeof network>
-      )
+      mockedNetwork.mockImplementation(() => networkResponse([makeOperation(++nextId)]))
 
       const result = await fetchAllTransactions(config, 'tz1acc')
 
@@ -921,7 +866,7 @@ describe('tzkt network API', () => {
   describe('api.getBlockByLevel', () => {
     it('calls the correct URL and returns the block', async () => {
       const block = makeApiBlock(999)
-      mockedNetwork.mockReturnValue(networkResponse(block) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(block))
 
       const result = await api.getBlockByLevel(999)
 
@@ -952,7 +897,7 @@ describe('tzkt network API', () => {
         networkResponse([
           [1234, 'BL-hash-1234'],
           [1235, 'BL-hash-1235'],
-        ]) as ReturnType<typeof network>
+        ])
       )
 
       const result = await api.getBlockHashesByLevels([1234, 1235])
@@ -973,9 +918,7 @@ describe('tzkt network API', () => {
     })
 
     it('omits levels that the API did not return', async () => {
-      mockedNetwork.mockReturnValue(
-        networkResponse([[1234, 'BL-hash-1234']]) as ReturnType<typeof network>
-      )
+      mockedNetwork.mockReturnValue(networkResponse([[1234, 'BL-hash-1234']]))
 
       const result = await api.getBlockHashesByLevels([1234, 9999])
 
@@ -990,24 +933,24 @@ describe('tzkt network API', () => {
 
   describe('api.getBlockTransactionsPage', () => {
     it('fetches a page without a cursor', async () => {
-      const txs: APITransactionType[] = [makeTxItem(1), makeTxItem(2)]
-      mockedNetwork.mockReturnValue(networkResponse(txs) as ReturnType<typeof network>)
+      const txs: DeepPartial<APITransactionType>[] = [makeTxItem(1), makeTxItem(2)]
+      mockedNetwork.mockReturnValue(networkResponse(txs))
 
       const result = await api.getBlockTransactionsPage(200)
 
       expect(result).toEqual(txs)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({ level: 200, limit: 1000, 'sort.asc': 'id' })
       expect(params).not.toHaveProperty('offset.cr')
     })
 
     it('includes offset.cr in params when cursor is provided', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockTransactionsPage(200, 42)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(42)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 42 })
     })
   })
 
@@ -1017,24 +960,24 @@ describe('tzkt network API', () => {
 
   describe('api.getBlockTokenTransfersPage', () => {
     it('fetches a page without a cursor', async () => {
-      const items: APITokenTransfer[] = [makeTokenItem(10)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      const items: DeepPartial<APITokenTransfer>[] = [makeTokenItem(10)]
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await api.getBlockTokenTransfersPage(300)
 
       expect(result).toEqual(items)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({ level: 300, limit: 1000, 'sort.asc': 'id' })
       expect(params).not.toHaveProperty('offset.cr')
     })
 
     it('includes offset.cr in params when cursor is provided', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockTokenTransfersPage(300, 77)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(77)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 77 })
     })
   })
 
@@ -1047,7 +990,7 @@ describe('tzkt network API', () => {
   // fetch maps to one `network(...)`; the cursor is passed through as the `offset.cr` param.
   describe('fetchBlockTransactions', () => {
     it('returns an empty array when the first page is empty', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await fetchBlockTransactions(config, 100)
 
@@ -1056,7 +999,7 @@ describe('tzkt network API', () => {
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const txs = [makeTxItem(1), makeTxItem(2)]
-      mockedNetwork.mockReturnValue(networkResponse(txs) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(txs))
 
       const result = await fetchBlockTransactions(config, 100)
 
@@ -1068,27 +1011,25 @@ describe('tzkt network API', () => {
       const lastPage = [makeTxItem(1001), makeTxItem(1002)]
 
       mockedNetwork
-        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(fullPage))
+        .mockReturnValueOnce(networkResponse(lastPage))
 
       const result = await fetchBlockTransactions(config, 100)
 
       expect(result).toHaveLength(1002)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
-      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
-        .params
+      const firstParams = mockedNetwork.mock.calls[0][0].params
       expect(firstParams).toMatchObject({ level: 100 })
       expect(firstParams).not.toHaveProperty('offset.cr')
       // cursor = last item id of first page = 1000
-      const secondParams = (mockedNetwork.mock.calls[1][0] as { params: Record<string, unknown> })
-        .params
+      const secondParams = mockedNetwork.mock.calls[1][0].params
       expect(secondParams).toMatchObject({ level: 100, 'offset.cr': 1000 })
     })
 
     it('stops after maxTxQuery iterations regardless of page length', async () => {
       // maxTxQuery = 100 (from mockConfig); every call returns a full page to keep the loop going
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTxItem(i + 1))
-      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
       const result = await fetchBlockTransactions(config, 100)
 
@@ -1108,7 +1049,7 @@ describe('tzkt network API', () => {
   // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockTokenTransfers', () => {
     it('returns an empty array when the first page is empty', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await fetchBlockTokenTransfers(config, 100)
 
@@ -1117,7 +1058,7 @@ describe('tzkt network API', () => {
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeTokenItem(1), makeTokenItem(2)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await fetchBlockTokenTransfers(config, 100)
 
@@ -1129,25 +1070,23 @@ describe('tzkt network API', () => {
       const lastPage = [makeTokenItem(1001)]
 
       mockedNetwork
-        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(fullPage))
+        .mockReturnValueOnce(networkResponse(lastPage))
 
       const result = await fetchBlockTokenTransfers(config, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
-      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
-        .params
+      const firstParams = mockedNetwork.mock.calls[0][0].params
       expect(firstParams).toMatchObject({ level: 100 })
       expect(firstParams).not.toHaveProperty('offset.cr')
-      const secondParams = (mockedNetwork.mock.calls[1][0] as { params: Record<string, unknown> })
-        .params
+      const secondParams = mockedNetwork.mock.calls[1][0].params
       expect(secondParams).toMatchObject({ level: 100, 'offset.cr': 1000 })
     })
 
     it('stops after maxTxQuery iterations regardless of page length', async () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTokenItem(i + 1))
-      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
       const result = await fetchBlockTokenTransfers(config, 100)
 
@@ -1166,28 +1105,28 @@ describe('tzkt network API', () => {
 
   describe('api.getBlockDelegationsPage', () => {
     it('fetches a page without a cursor', async () => {
-      const items: APIDelegationType[] = [makeDelegationItem(10)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      const items: DeepPartial<APIDelegationType>[] = [makeDelegationItem(10)]
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await api.getBlockDelegationsPage(400)
 
       expect(result).toEqual(items)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({ level: 400, limit: 1000, 'sort.asc': 'id' })
       expect(params).not.toHaveProperty('offset.cr')
     })
 
     it('includes offset.cr in params when cursor is provided', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockDelegationsPage(400, 88)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(88)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 88 })
     })
 
     it('calls the delegations endpoint', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockDelegationsPage(500)
 
@@ -1206,7 +1145,7 @@ describe('tzkt network API', () => {
   // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockDelegations', () => {
     it('returns an empty array when the first page is empty', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await fetchBlockDelegations(config, 100)
 
@@ -1215,7 +1154,7 @@ describe('tzkt network API', () => {
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeDelegationItem(1), makeDelegationItem(2)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await fetchBlockDelegations(config, 100)
 
@@ -1227,25 +1166,23 @@ describe('tzkt network API', () => {
       const lastPage = [makeDelegationItem(1001)]
 
       mockedNetwork
-        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(fullPage))
+        .mockReturnValueOnce(networkResponse(lastPage))
 
       const result = await fetchBlockDelegations(config, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
-      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
-        .params
+      const firstParams = mockedNetwork.mock.calls[0][0].params
       expect(firstParams).toMatchObject({ level: 100 })
       expect(firstParams).not.toHaveProperty('offset.cr')
-      const secondParams = (mockedNetwork.mock.calls[1][0] as { params: Record<string, unknown> })
-        .params
+      const secondParams = mockedNetwork.mock.calls[1][0].params
       expect(secondParams).toMatchObject({ level: 100, 'offset.cr': 1000 })
     })
 
     it('stops after maxTxQuery iterations regardless of page length', async () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeDelegationItem(i + 1))
-      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
       const result = await fetchBlockDelegations(config, 100)
 
@@ -1264,28 +1201,28 @@ describe('tzkt network API', () => {
 
   describe('api.getBlockStakingPage', () => {
     it('fetches a page without a cursor', async () => {
-      const items: APIStakingType[] = [makeStakingItem(10)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      const items: DeepPartial<APIStakingType>[] = [makeStakingItem(10)]
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await api.getBlockStakingPage(400)
 
       expect(result).toEqual(items)
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
+      const params = mockedNetwork.mock.calls[0][0].params
       expect(params).toMatchObject({ level: 400, limit: 1000, 'sort.asc': 'id' })
       expect(params).not.toHaveProperty('offset.cr')
     })
 
     it('includes offset.cr in params when cursor is provided', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockStakingPage(400, 88)
 
-      const params = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> }).params
-      expect(params['offset.cr']).toBe(88)
+      const params = mockedNetwork.mock.calls[0][0].params
+      expect(params).toMatchObject({ 'offset.cr': 88 })
     })
 
     it('calls the staking endpoint', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       await api.getBlockStakingPage(500)
 
@@ -1304,7 +1241,7 @@ describe('tzkt network API', () => {
   // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockStaking', () => {
     it('returns an empty array when the first page is empty', async () => {
-      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse([]))
 
       const result = await fetchBlockStaking(config, 100)
 
@@ -1313,7 +1250,7 @@ describe('tzkt network API', () => {
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeStakingItem(1), makeStakingItem(2)]
-      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(items))
 
       const result = await fetchBlockStaking(config, 100)
 
@@ -1325,25 +1262,23 @@ describe('tzkt network API', () => {
       const lastPage = [makeStakingItem(1001)]
 
       mockedNetwork
-        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
-        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(fullPage))
+        .mockReturnValueOnce(networkResponse(lastPage))
 
       const result = await fetchBlockStaking(config, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
-      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
-        .params
+      const firstParams = mockedNetwork.mock.calls[0][0].params
       expect(firstParams).toMatchObject({ level: 100 })
       expect(firstParams).not.toHaveProperty('offset.cr')
-      const secondParams = (mockedNetwork.mock.calls[1][0] as { params: Record<string, unknown> })
-        .params
+      const secondParams = mockedNetwork.mock.calls[1][0].params
       expect(secondParams).toMatchObject({ level: 100, 'offset.cr': 1000 })
     })
 
     it('stops after maxTxQuery iterations regardless of page length', async () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeStakingItem(i + 1))
-      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
       const result = await fetchBlockStaking(config, 100)