@ledgerhq/coin-tezos 7.12.0 → 9.0.0

package/src/network/bakers.test.ts

@@ -4,13 +4,16 @@
 import type { TezosCoinConfig } from '../config'
 import type { TezosApiBaker } from './bakers'
 import network from '@ledgerhq/live-network/network'
-import coinConfig from '../config'
 import { mockConfig } from '../test/config'
 import { asBaker, cache } from './bakers'
 
 jest.mock('@ledgerhq/live-network/network')
 const mockedNetwork = jest.mocked(network)
 
+// `cache` is keyed by config (its LRU resolver is `config.baker.url`), so it must be called with a
+// config. Previously the config was provided via `coinConfig.setCoinConfig(...)`.
+const config = mockConfig as TezosCoinConfig
+
 const data: TezosApiBaker[] = [
   {
     address: 'tz1Kf25fX1VdmYGSEzwFy1wNmkbSEZ2V83sY',
@@ -167,10 +170,6 @@ const data: TezosApiBaker[] = [
 ]
 
 describe('Tezos Baker', () => {
-  beforeAll(() => {
-    coinConfig.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig)
-  })
-
   afterEach(() => {
     jest.clearAllMocks()
     cache.reset()
@@ -192,7 +191,7 @@ describe('Tezos Baker', () => {
     })
 
     it('Ledger Baker should be first in the list', async () => {
-      const bakers = await cache()
+      const bakers = await cache(config)
       expect(bakers[0].name).toBe('Ledger by Kiln')
     })
   })

package/src/network/bakers.ts

@@ -1,11 +1,11 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosCoinConfig } from '../config'
 import type { Baker } from '../types'
 import { makeLRUCache } from '@ledgerhq/live-network/cache'
 import network from '@ledgerhq/live-network/network'
 import { log } from '@ledgerhq/logs'
-import coinConfig from '../config'
 import { ledgerValidatorAddress } from './bakers.whitelist-default'
 
 export type TezosApiBaker = {
@@ -40,9 +40,9 @@ export type TezosBakerFeature = {
 }
 
 export const cache = makeLRUCache(
-  async (): Promise<Baker[]> => {
+  async (config: TezosCoinConfig): Promise<Baker[]> => {
     const bakers: Baker[] = []
-    const TEZOS_API_BASE_URL = coinConfig.getCoinConfig().baker.url
+    const TEZOS_API_BASE_URL = config.baker.url
     const { data } = await network<TezosApiBaker[]>({
       url: `${TEZOS_API_BASE_URL}/v3/bakers`,
     })
@@ -67,13 +67,13 @@ export const cache = makeLRUCache(
     log('tezos/bakers', 'loaded ' + bakers.length + ' bakers')
     return [ledgerBaker, ...bakers]
   },
-  () => ''
+  (config: TezosCoinConfig) => config.baker.url
 )
 
 let _lastBakers: Baker[] = []
 
-export const fetchAllBakers = async (): Promise<Baker[]> => {
-  const allBakers = await cache.force()
+export const fetchAllBakers = async (config: TezosCoinConfig): Promise<Baker[]> => {
+  const allBakers = await cache.force(config)
   _lastBakers = allBakers
   return allBakers
 }
@@ -85,8 +85,11 @@ export const listBakersWithDefault = (whitelistAddresses: string[]): Baker[] =>
   return whitelist(_lastBakers, whitelistAddresses)
 }
 
-export const listBakers = async (whitelistAddresses: string[]): Promise<Baker[]> => {
-  _lastBakers = await cache()
+export const listBakers = async (
+  config: TezosCoinConfig,
+  whitelistAddresses: string[]
+): Promise<Baker[]> => {
+  _lastBakers = await cache(config)
   return whitelist(_lastBakers, whitelistAddresses)
 }
 
@@ -94,10 +97,10 @@ export function getBakerSync(addr: string): Baker | undefined {
   return _lastBakers.find((baker) => baker.address === addr)
 }
 
-export async function loadBaker(addr: string): Promise<Baker | undefined> {
+export async function loadBaker(config: TezosCoinConfig, addr: string): Promise<Baker | undefined> {
   const cacheBaker = getBakerSync(addr)
   if (cacheBaker) return cacheBaker
-  const bakers = await cache()
+  const bakers = await cache(config)
   const baker = bakers.find((baker) => baker.address === addr)
   return baker
 }

package/src/network/index.ts

@@ -5,7 +5,8 @@ import * as bakers from './bakers'
 
 export { bakers }
 export {
-  default as tzkt,
+  createTzktApi,
+  type TzktApi,
   fetchAllTransactions,
   fetchBlockDelegations,
   fetchBlockOriginations,

package/src/network/tzkt.integ.test.ts

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { TezosCoinConfig } from '../config'
-import coinConfig from '../config'
-import api from './tzkt'
+import { createTzktApi } from './tzkt'
 
 /**
  * Mainnet integration tests for multi-asset FA2 support (LIVE-29210).
@@ -33,18 +32,8 @@ const mainnetConfig = (): TezosCoinConfig =>
   }) as TezosCoinConfig
 
 describe('TzKT multi-asset FA2 — mainnet', () => {
-  let originalGetCoinConfig: () => TezosCoinConfig
-
-  beforeAll(() => {
-    originalGetCoinConfig = coinConfig.getCoinConfig
-    coinConfig.setCoinConfig(mainnetConfig)
-  })
-
-  afterAll(() => {
-    if (originalGetCoinConfig) {
-      coinConfig.setCoinConfig(originalGetCoinConfig)
-    }
-  })
+  const config: TezosCoinConfig = mainnetConfig()
+  const api = createTzktApi(config)
 
   describe('getTokensBalances', () => {
     it('returns balances for multiple tokenIds on the same contract', async () => {

package/src/network/tzkt.test.ts

@@ -13,15 +13,13 @@ import type {
   APITokenBalance,
   APITokenTransfer,
   APITransactionType,
-  AccountsGetOperationsOptions,
 } from './types'
 // 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'
 import { log } from '@ledgerhq/logs'
-import coinConfig from '../config'
 import { mockConfig } from '../test/config'
-import api from './tzkt'
+import { createTzktApi } from './tzkt'
 import {
   fetchAllTransactions,
   fetchBlockDelegations,
@@ -35,6 +33,18 @@ jest.mock('@ledgerhq/logs')
 const mockedNetwork = jest.mocked(network)
 const mockedLog = jest.mocked(log)
 
+// The tzkt module is NOT mocked here. `createTzktApi(config)` returns a plain object whose methods
+// close over `config.explorer.url` and delegate to the mocked `network`. Each method also calls its
+// sibling methods through this same object (closure, not `this`), so spying on the instance's
+// methods (see `spyOnApi`) intercepts intra-object calls such as `getAccountTokenTransfers` →
+// `getOperationsTransactions`.
+//
+// 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 api = createTzktApi(config)
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -106,10 +116,6 @@ function spyOnApi<K extends keyof typeof api>(method: K) {
 // ---------------------------------------------------------------------------
 
 describe('tzkt network API', () => {
-  beforeAll(() => {
-    coinConfig.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig)
-  })
-
   afterEach(() => {
     localSpies.splice(0).forEach((spy) => spy.mockRestore())
     jest.clearAllMocks()
@@ -847,59 +853,63 @@ describe('tzkt network API', () => {
   // fetchAllTransactions
   // -------------------------------------------------------------------------
 
+  // `fetchAllTransactions` builds its own internal `createTzktApi(config)` instance and calls
+  // `getAccountOperations` on it, so a spy on the local `api` cannot intercept it. Instead we drive
+  // the mocked `network`: each `getAccountOperations` call maps to exactly one `network(...)` whose
+  // `.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 () => {
-      spyOnApi('getAccountOperations').mockResolvedValue([])
+      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchAllTransactions('tz1acc')
+      const result = await fetchAllTransactions(config, 'tz1acc')
 
       expect(result).toEqual([])
     })
 
     it('concatenates pages until an empty response', async () => {
-      const spy = jest
-        .spyOn(api, 'getAccountOperations')
-        .mockResolvedValueOnce([makeOperation(1)])
-        .mockResolvedValueOnce([makeOperation(2)])
-        .mockResolvedValueOnce([])
+      mockedNetwork
+        .mockReturnValueOnce(networkResponse([makeOperation(1)]) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse([makeOperation(2)]) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchAllTransactions('tz1acc')
+      const result = await fetchAllTransactions(config, 'tz1acc')
 
       expect(result).toEqual([makeOperation(1), makeOperation(2)])
-      expect(spy).toHaveBeenCalledTimes(3)
-      expect(spy).toHaveBeenNthCalledWith(1, 'tz1acc', {
-        lastId: undefined,
-        sort: 'Ascending',
-        'level.ge': 0,
-      })
-      expect(spy).toHaveBeenNthCalledWith(2, 'tz1acc', {
-        lastId: 1,
-        sort: 'Ascending',
-        'level.ge': 0,
-      })
+      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
+      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
+      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
-      spyOnApi('getAccountOperations').mockResolvedValue([opMissingId])
+      mockedNetwork.mockReturnValue(networkResponse([opMissingId]) as ReturnType<typeof network>)
 
-      const result = await fetchAllTransactions('tz1acc')
+      const result = await fetchAllTransactions(config, 'tz1acc')
 
       expect(result).toEqual([opMissingId])
       expect(mockedLog).toHaveBeenCalledWith('tezos', 'id missing!')
     })
 
     it('stops after maxTxQuery iterations', async () => {
-      const spy = jest
-        .spyOn(api, 'getAccountOperations')
-        .mockImplementation(async (_addr: string, opts: AccountsGetOperationsOptions) => {
-          // Always one op with a truthy id so the loop would continue without the cap
-          return [makeOperation((opts.lastId ?? 0) + 1)]
-        })
+      // 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>
+      )
 
-      const result = await fetchAllTransactions('tz1acc')
+      const result = await fetchAllTransactions(config, 'tz1acc')
 
-      expect(spy).toHaveBeenCalledTimes(mockConfig.explorer.maxTxQuery)
+      expect(mockedNetwork).toHaveBeenCalledTimes(mockConfig.explorer.maxTxQuery)
       expect(result).toHaveLength(mockConfig.explorer.maxTxQuery)
     })
   })
@@ -1032,20 +1042,23 @@ describe('tzkt network API', () => {
   // fetchBlockTransactions — pagination logic
   // -------------------------------------------------------------------------
 
+  // `fetchBlockTransactions` builds its own internal `createTzktApi(config)` and calls
+  // `getBlockTransactionsPage` on it, so a spy on the local `api` cannot intercept it. Each page
+  // 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 () => {
-      spyOnApi('getBlockTransactionsPage').mockResolvedValue([])
+      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTransactions(100)
+      const result = await fetchBlockTransactions(config, 100)
 
       expect(result).toEqual([])
     })
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const txs = [makeTxItem(1), makeTxItem(2)]
-      spyOnApi('getBlockTransactionsPage').mockResolvedValue(txs)
+      mockedNetwork.mockReturnValue(networkResponse(txs) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTransactions(100)
+      const result = await fetchBlockTransactions(config, 100)
 
       expect(result).toEqual(txs)
     })
@@ -1054,28 +1067,32 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTxItem(i + 1))
       const lastPage = [makeTxItem(1001), makeTxItem(1002)]
 
-      const spy = jest
-        .spyOn(api, 'getBlockTransactionsPage')
-        .mockResolvedValueOnce(fullPage)
-        .mockResolvedValueOnce(lastPage)
+      mockedNetwork
+        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTransactions(100)
+      const result = await fetchBlockTransactions(config, 100)
 
       expect(result).toHaveLength(1002)
-      expect(spy).toHaveBeenCalledTimes(2)
-      expect(spy).toHaveBeenNthCalledWith(1, 100, undefined)
+      expect(mockedNetwork).toHaveBeenCalledTimes(2)
+      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
+        .params
+      expect(firstParams).toMatchObject({ level: 100 })
+      expect(firstParams).not.toHaveProperty('offset.cr')
       // cursor = last item id of first page = 1000
-      expect(spy).toHaveBeenNthCalledWith(2, 100, 1000)
+      const secondParams = (mockedNetwork.mock.calls[1][0] as { params: Record<string, unknown> })
+        .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))
-      const spy = spyOnApi('getBlockTransactionsPage').mockResolvedValue(fullPage)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTransactions(100)
+      const result = await fetchBlockTransactions(config, 100)
 
-      expect(spy).toHaveBeenCalledTimes(100)
+      expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
       expect(mockedLog).toHaveBeenCalledWith(
         'tezos',
@@ -1088,20 +1105,21 @@ describe('tzkt network API', () => {
   // fetchBlockTokenTransfers — pagination logic
   // -------------------------------------------------------------------------
 
+  // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockTokenTransfers', () => {
     it('returns an empty array when the first page is empty', async () => {
-      spyOnApi('getBlockTokenTransfersPage').mockResolvedValue([])
+      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTokenTransfers(100)
+      const result = await fetchBlockTokenTransfers(config, 100)
 
       expect(result).toEqual([])
     })
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeTokenItem(1), makeTokenItem(2)]
-      spyOnApi('getBlockTokenTransfersPage').mockResolvedValue(items)
+      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTokenTransfers(100)
+      const result = await fetchBlockTokenTransfers(config, 100)
 
       expect(result).toEqual(items)
     })
@@ -1110,26 +1128,30 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTokenItem(i + 1))
       const lastPage = [makeTokenItem(1001)]
 
-      const spy = jest
-        .spyOn(api, 'getBlockTokenTransfersPage')
-        .mockResolvedValueOnce(fullPage)
-        .mockResolvedValueOnce(lastPage)
+      mockedNetwork
+        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTokenTransfers(100)
+      const result = await fetchBlockTokenTransfers(config, 100)
 
       expect(result).toHaveLength(1001)
-      expect(spy).toHaveBeenCalledTimes(2)
-      expect(spy).toHaveBeenNthCalledWith(1, 100, undefined)
-      expect(spy).toHaveBeenNthCalledWith(2, 100, 1000)
+      expect(mockedNetwork).toHaveBeenCalledTimes(2)
+      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
+        .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
+      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))
-      const spy = spyOnApi('getBlockTokenTransfersPage').mockResolvedValue(fullPage)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockTokenTransfers(100)
+      const result = await fetchBlockTokenTransfers(config, 100)
 
-      expect(spy).toHaveBeenCalledTimes(100)
+      expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
       expect(mockedLog).toHaveBeenCalledWith(
         'tezos',
@@ -1181,20 +1203,21 @@ describe('tzkt network API', () => {
   // fetchBlockDelegations — pagination logic
   // -------------------------------------------------------------------------
 
+  // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockDelegations', () => {
     it('returns an empty array when the first page is empty', async () => {
-      spyOnApi('getBlockDelegationsPage').mockResolvedValue([])
+      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchBlockDelegations(100)
+      const result = await fetchBlockDelegations(config, 100)
 
       expect(result).toEqual([])
     })
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeDelegationItem(1), makeDelegationItem(2)]
-      spyOnApi('getBlockDelegationsPage').mockResolvedValue(items)
+      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
 
-      const result = await fetchBlockDelegations(100)
+      const result = await fetchBlockDelegations(config, 100)
 
       expect(result).toEqual(items)
     })
@@ -1203,26 +1226,30 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeDelegationItem(i + 1))
       const lastPage = [makeDelegationItem(1001)]
 
-      const spy = jest
-        .spyOn(api, 'getBlockDelegationsPage')
-        .mockResolvedValueOnce(fullPage)
-        .mockResolvedValueOnce(lastPage)
+      mockedNetwork
+        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockDelegations(100)
+      const result = await fetchBlockDelegations(config, 100)
 
       expect(result).toHaveLength(1001)
-      expect(spy).toHaveBeenCalledTimes(2)
-      expect(spy).toHaveBeenNthCalledWith(1, 100, undefined)
-      expect(spy).toHaveBeenNthCalledWith(2, 100, 1000)
+      expect(mockedNetwork).toHaveBeenCalledTimes(2)
+      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
+        .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
+      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))
-      const spy = spyOnApi('getBlockDelegationsPage').mockResolvedValue(fullPage)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockDelegations(100)
+      const result = await fetchBlockDelegations(config, 100)
 
-      expect(spy).toHaveBeenCalledTimes(100)
+      expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
       expect(mockedLog).toHaveBeenCalledWith(
         'tezos',
@@ -1274,20 +1301,21 @@ describe('tzkt network API', () => {
   // fetchBlockStaking — pagination logic
   // -------------------------------------------------------------------------
 
+  // Driven through the mocked `network` (see the note on `fetchBlockTransactions`).
   describe('fetchBlockStaking', () => {
     it('returns an empty array when the first page is empty', async () => {
-      spyOnApi('getBlockStakingPage').mockResolvedValue([])
+      mockedNetwork.mockReturnValue(networkResponse([]) as ReturnType<typeof network>)
 
-      const result = await fetchBlockStaking(100)
+      const result = await fetchBlockStaking(config, 100)
 
       expect(result).toEqual([])
     })
 
     it('returns a single page when the page is smaller than the page size', async () => {
       const items = [makeStakingItem(1), makeStakingItem(2)]
-      spyOnApi('getBlockStakingPage').mockResolvedValue(items)
+      mockedNetwork.mockReturnValue(networkResponse(items) as ReturnType<typeof network>)
 
-      const result = await fetchBlockStaking(100)
+      const result = await fetchBlockStaking(config, 100)
 
       expect(result).toEqual(items)
     })
@@ -1296,26 +1324,30 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeStakingItem(i + 1))
       const lastPage = [makeStakingItem(1001)]
 
-      const spy = jest
-        .spyOn(api, 'getBlockStakingPage')
-        .mockResolvedValueOnce(fullPage)
-        .mockResolvedValueOnce(lastPage)
+      mockedNetwork
+        .mockReturnValueOnce(networkResponse(fullPage) as ReturnType<typeof network>)
+        .mockReturnValueOnce(networkResponse(lastPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockStaking(100)
+      const result = await fetchBlockStaking(config, 100)
 
       expect(result).toHaveLength(1001)
-      expect(spy).toHaveBeenCalledTimes(2)
-      expect(spy).toHaveBeenNthCalledWith(1, 100, undefined)
-      expect(spy).toHaveBeenNthCalledWith(2, 100, 1000)
+      expect(mockedNetwork).toHaveBeenCalledTimes(2)
+      const firstParams = (mockedNetwork.mock.calls[0][0] as { params: Record<string, unknown> })
+        .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
+      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))
-      const spy = spyOnApi('getBlockStakingPage').mockResolvedValue(fullPage)
+      mockedNetwork.mockReturnValue(networkResponse(fullPage) as ReturnType<typeof network>)
 
-      const result = await fetchBlockStaking(100)
+      const result = await fetchBlockStaking(config, 100)
 
-      expect(spy).toHaveBeenCalledTimes(100)
+      expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
       expect(mockedLog).toHaveBeenCalledWith(
         'tezos',