@ledgerhq/coin-tezos 10.2.1 → 10.2.4

package/src/logic/validateIntent.ts

@@ -14,6 +14,7 @@ import {
   NotEnoughBalance,
   AmountRequired,
   InvalidAddressBecauseDestinationIsAlsoSource,
+  UnexpectedGetBalanceError,
 } from '@ledgerhq/coin-module-framework/errors'
 import { validateAddress, ValidationResult } from '@taquito/utils'
 import { hasManagerKey } from '../network/types'
@@ -23,6 +24,7 @@ import {
   MustDelegateBeforeStaking,
   NotEnoughBalanceToDelegate,
   TezosNotEnoughStaked,
+  TezosStakeAmountTooSmall,
   TezosStakeBlockedByPendingUnstake,
 } from '../types/errors'
 import {
@@ -30,6 +32,7 @@ import {
   parseTezosTokenAsset,
   partitionNativeBalance,
   resolveTezosOperationMode,
+  STAKE_ESTIMATION_PROBE_MUTEZ,
 } from '../utils'
 import { estimateFees } from './estimateFees'
 
@@ -155,6 +158,9 @@ function mapTaquitoErrors(taquitoError: string, intentType: string): Record<stri
     errors.amount = new TezosNotEnoughStaked()
   } else if (taquitoError.endsWith('contract.must_be_delegated_to_stake')) {
     errors.amount = new MustDelegateBeforeStaking()
+  } else if (taquitoError.endsWith('stake_amount_too_small')) {
+    // Below one staking pseudotoken the stake mints nothing; see STAKE_ESTIMATION_PROBE_MUTEZ.
+    errors.amount = new TezosStakeAmountTooSmall()
   } else if (
     taquitoError.endsWith('cannot_stake_with_unfinalizable_unstake_requests_to_another_delegate')
   ) {
@@ -165,10 +171,10 @@ function mapTaquitoErrors(taquitoError: string, intentType: string): Record<stri
     // Re-delegating (or staking) to the current baker leaves the delegate unchanged; the node
     // rejects it. Surfaces for both `delegate` and `stake` intents as "already delegated".
     errors.recipient = new InvalidAddressBecauseAlreadyDelegated()
-  } else if (taquitoError.includes('empty_implicit_contract')) {
+  } else if (taquitoError.endsWith('empty_implicit_contract')) {
     errors.amount =
       intentType === 'stake' ? new NotEnoughBalance() : new NotEnoughBalanceToDelegate()
-  } else if (taquitoError.includes('script_rejected')) {
+  } else if (taquitoError.endsWith('script_rejected')) {
     errors.amount = new NotEnoughBalance()
   } else {
     errors.amount = new Error(taquitoError)
@@ -397,17 +403,25 @@ export async function validateIntent(
     // the outer handler (which would wipe the already-computed estimatedFees and add a spurious
     // errors.estimation on top of the real fee-estimation error).
     let tokenBalance: bigint | undefined
+    let tokenBalanceError: unknown
     if (errors.amount && !intent.useAllAmount) {
       tokenBalance = undefined
     } else {
       try {
         tokenBalance = await fetchTokenBalance(config, intent)
-      } catch {
-        tokenBalance = undefined // TzKT unreachable: fall back gracefully, no token coverage check
+      } catch (e) {
+        tokenBalance = undefined
+        tokenBalanceError = e
       }
     }
-    // send-max uses the full token balance as the sent amount; fixed-amount only needs it for coverage
-    const tokenBalanceForSendMax = intent.useAllAmount ? tokenBalance : undefined
+
+    // Never pass `undefined` for a token send-max: that triggers the native-branch/wrong-unit
+    // fallback described above. An unresolved balance becomes 0n; the guards below set the error.
+    const isTokenSendMax =
+      intent.type === 'send' &&
+      !!intent.useAllAmount &&
+      resolveTezosOperationMode(intent.type, intent.asset) === 'send_token'
+    const tokenBalanceForSendMax = isTokenSendMax ? (tokenBalance ?? 0n) : undefined
 
     const amounts = calculateAmounts(
       intent,
@@ -419,10 +433,36 @@ export async function validateIntent(
     amount = amounts.amount
     totalSpent = amounts.totalSpent
 
-    if (intent.type === 'stake' && intent.useAllAmount && amount === 0n && !errors.amount) {
+    // An unreachable TzKT is not an empty balance. Both block, but reporting NotEnoughBalance
+    // here would tell a user who holds the token that they have insufficient funds.
+    if (isTokenSendMax && tokenBalanceError !== undefined && !errors.amount) {
+      errors.amount = new UnexpectedGetBalanceError(undefined, tokenBalanceError)
+    }
+
+    // A send-max resolving to 0n must block. validateBalanceCoverage below only compares native
+    // spendable against totalSpent, which a 0-amount transaction always satisfies, so nothing
+    // else catches it.
+    // `finalize_unstake` is excluded: it is parameter-less and 0n by construction.
+    if (
+      (intent.type === 'send' || intent.type === 'stake') &&
+      intent.useAllAmount &&
+      amount === 0n &&
+      !errors.amount
+    ) {
       errors.amount = new NotEnoughBalance()
     }
 
+    // Estimation simulates the probe, never the resolved max; below the probe the stake may still
+    // mint no pseudotoken and be refused at injection.
+    if (
+      intent.type === 'stake' &&
+      intent.useAllAmount &&
+      amount < STAKE_ESTIMATION_PROBE_MUTEZ &&
+      !errors.amount
+    ) {
+      errors.amount = new TezosStakeAmountTooSmall()
+    }
+
     const { spendable } = partitionNativeBalance(
       BigInt(senderInfo.balance),
       BigInt(senderInfo.stakedBalance ?? 0),
@@ -431,8 +471,8 @@ export async function validateIntent(
     const balanceErrors = validateBalanceCoverage(spendable, totalSpent)
     Object.assign(errors, balanceErrors)
 
-    // Token balance coverage for fixed-amount token sends.
-    // (send-max is always valid by construction: amount is set to tokenBalance above.)
+    // Token balance coverage for fixed-amount token sends. send-max needs none: amount is the
+    // token balance itself, and the zero/unresolved cases already errored above.
     if (
       !errors.amount &&
       intent.type === 'send' &&

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

@@ -1,16 +1,17 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig } from '../config'
+import type { TezosCoinConfig, TezosContext } from '../config'
 import { listBakers } from '../network/bakers'
 import whitelist from '../network/bakers.whitelist-default'
 import { mockConfig } from '../test/config'
 
 describe('tezos bakers', () => {
   const config: TezosCoinConfig = mockConfig
+  const context: TezosContext = { config: async () => config, logger: jest.fn() }
 
   test('atleast 10 whitelisted bakers are online', async () => {
-    const onlineBakersCount = (await listBakers(config, whitelist))
+    const onlineBakersCount = (await listBakers(context, whitelist))
       .map((baker) => baker.address)
       .filter((address) => whitelist.includes(address)).length
     expect(onlineBakersCount).toBeGreaterThan(10)

package/src/network/bakers.test.ts

@@ -7,6 +7,7 @@ import { mockConfig } from '../test/config'
 import { asBaker, cache } from './bakers'
 
 const mockNetworkFn = jest.fn()
+const mockLogger = jest.fn()
 jest.mock('@ledgerhq/live-network/network', () => ({
   __esModule: true,
   default: (...args: unknown[]) => mockNetworkFn(...args),
@@ -183,7 +184,7 @@ describe('Tezos Baker', () => {
     })
 
     it('Ledger Baker should be first in the list', async () => {
-      const bakers = await cache(config)
+      const bakers = await cache(config, mockLogger)
       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 { TezosCoinConfig, TezosContext } from '../config'
 import type { Baker } from '../types'
+import type { Logger } from '@ledgerhq/coin-module-framework/config'
 import { makeLRUCache } from '@ledgerhq/live-network/cache'
 import network from '@ledgerhq/live-network/network'
-import { log } from '@ledgerhq/logs'
 import { ledgerValidatorAddress } from './bakers.whitelist-default'
 
 export type TezosApiBaker = {
@@ -40,7 +40,7 @@ export type TezosBakerFeature = {
 }
 
 export const cache = makeLRUCache(
-  async (config: TezosCoinConfig): Promise<Baker[]> => {
+  async (config: TezosCoinConfig, logger: Logger): Promise<Baker[]> => {
     const bakers: Baker[] = []
     const TEZOS_API_BASE_URL = config.baker.url
     const { data } = await network<TezosApiBaker[]>({
@@ -48,7 +48,7 @@ export const cache = makeLRUCache(
     })
 
     if (data && Array.isArray(data)) {
-      log('tezos/bakers', 'found ' + data.length + ' bakers')
+      logger('tezos/bakers', 'found ' + data.length + ' bakers')
       data
         .filter((raw) => raw.status === 'active' && raw.delegation.enabled)
         .forEach((raw) => {
@@ -64,7 +64,7 @@ export const cache = makeLRUCache(
     const ledgerBakerIndex = bakers.findIndex((baker) => baker.address === ledgerValidatorAddress)
     const [ledgerBaker] = bakers.splice(ledgerBakerIndex, 1)
 
-    log('tezos/bakers', 'loaded ' + bakers.length + ' bakers')
+    logger('tezos/bakers', 'loaded ' + bakers.length + ' bakers')
     return [ledgerBaker, ...bakers]
   },
   (config: TezosCoinConfig) => config.baker.url
@@ -72,8 +72,9 @@ export const cache = makeLRUCache(
 
 let _lastBakers: Baker[] = []
 
-export const fetchAllBakers = async (config: TezosCoinConfig): Promise<Baker[]> => {
-  const allBakers = await cache.force(config)
+export const fetchAllBakers = async (context: TezosContext): Promise<Baker[]> => {
+  const config = await context.config()
+  const allBakers = await cache.force(config, context.logger)
   _lastBakers = allBakers
   return allBakers
 }
@@ -86,10 +87,11 @@ export const listBakersWithDefault = (whitelistAddresses: string[]): Baker[] =>
 }
 
 export const listBakers = async (
-  config: TezosCoinConfig,
+  context: TezosContext,
   whitelistAddresses: string[]
 ): Promise<Baker[]> => {
-  _lastBakers = await cache(config)
+  const config = await context.config()
+  _lastBakers = await cache(config, context.logger)
   return whitelist(_lastBakers, whitelistAddresses)
 }
 
@@ -97,12 +99,12 @@ export function getBakerSync(addr: string): Baker | undefined {
   return _lastBakers.find((baker) => baker.address === addr)
 }
 
-export async function loadBaker(config: TezosCoinConfig, addr: string): Promise<Baker | undefined> {
+export async function loadBaker(context: TezosContext, addr: string): Promise<Baker | undefined> {
   const cacheBaker = getBakerSync(addr)
   if (cacheBaker) return cacheBaker
-  const bakers = await cache(config)
-  const baker = bakers.find((baker) => baker.address === addr)
-  return baker
+  const config = await context.config()
+  const bakers = await cache(config, context.logger)
+  return bakers.find((baker) => baker.address === addr)
 }
 
 export const asBaker = (data: TezosApiBaker): Baker | undefined => {

package/src/network/tzkt.test.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig } from '../config'
+import type { TezosCoinConfig, TezosContext } from '../config'
 // Import fetchBlockTransactions / fetchBlockTokenTransfers / fetchBlockDelegations through the index re-export
 // so that network/index.ts line 4 is exercised and its coverage is tracked.
 import type {
@@ -18,7 +18,6 @@ import type { DeepPartial, DeepPartialReturn } from '@ledgerhq/coin-module-frame
 // 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 { mockConfig } from '../test/config'
 import { createTzktApi } from './tzkt'
 import {
@@ -30,9 +29,10 @@ import {
 } from '.'
 
 jest.mock('@ledgerhq/live-network')
-jest.mock('@ledgerhq/logs')
 const mockedNetwork = jest.mocked<DeepPartialReturn<typeof network>>(network)
-const mockedLog = jest.mocked(log)
+const mockLogger = jest.fn()
+const config: TezosCoinConfig = mockConfig
+const context: TezosContext = { config: async () => config, logger: mockLogger }
 
 // 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
@@ -43,7 +43,6 @@ 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: TezosCoinConfig = mockConfig
 const api = createTzktApi(config)
 
 // ---------------------------------------------------------------------------
@@ -808,7 +807,7 @@ describe('tzkt network API', () => {
     it('returns empty when the first page is empty', async () => {
       mockedNetwork.mockReturnValue(networkResponse([]))
 
-      const result = await fetchAllTransactions(config, 'tz1acc')
+      const result = await fetchAllTransactions(context, 'tz1acc')
 
       expect(result).toEqual([])
     })
@@ -819,7 +818,7 @@ describe('tzkt network API', () => {
         .mockReturnValueOnce(networkResponse([makeOperation(2)]))
         .mockReturnValueOnce(networkResponse([]))
 
-      const result = await fetchAllTransactions(config, 'tz1acc')
+      const result = await fetchAllTransactions(context, 'tz1acc')
 
       expect(result).toEqual([makeOperation(1), makeOperation(2)])
       expect(mockedNetwork).toHaveBeenCalledTimes(3)
@@ -840,10 +839,10 @@ describe('tzkt network API', () => {
       const opMissingId: DeepPartial<APIOperation> = { ...makeOperation(1), id: 0 }
       mockedNetwork.mockReturnValue(networkResponse([opMissingId]))
 
-      const result = await fetchAllTransactions(config, 'tz1acc')
+      const result = await fetchAllTransactions(context, 'tz1acc')
 
       expect(result).toEqual([opMissingId])
-      expect(mockedLog).toHaveBeenCalledWith('tezos', 'id missing!')
+      expect(mockLogger).toHaveBeenCalledWith('tezos', 'id missing!')
     })
 
     it('stops after maxTxQuery iterations', async () => {
@@ -852,7 +851,7 @@ describe('tzkt network API', () => {
       let nextId = 0
       mockedNetwork.mockImplementation(() => networkResponse([makeOperation(++nextId)]))
 
-      const result = await fetchAllTransactions(config, 'tz1acc')
+      const result = await fetchAllTransactions(context, 'tz1acc')
 
       expect(mockedNetwork).toHaveBeenCalledTimes(mockConfig.explorer.maxTxQuery)
       expect(result).toHaveLength(mockConfig.explorer.maxTxQuery)
@@ -992,7 +991,7 @@ describe('tzkt network API', () => {
     it('returns an empty array when the first page is empty', async () => {
       mockedNetwork.mockReturnValue(networkResponse([]))
 
-      const result = await fetchBlockTransactions(config, 100)
+      const result = await fetchBlockTransactions(context, 100)
 
       expect(result).toEqual([])
     })
@@ -1001,7 +1000,7 @@ describe('tzkt network API', () => {
       const txs = [makeTxItem(1), makeTxItem(2)]
       mockedNetwork.mockReturnValue(networkResponse(txs))
 
-      const result = await fetchBlockTransactions(config, 100)
+      const result = await fetchBlockTransactions(context, 100)
 
       expect(result).toEqual(txs)
     })
@@ -1014,7 +1013,7 @@ describe('tzkt network API', () => {
         .mockReturnValueOnce(networkResponse(fullPage))
         .mockReturnValueOnce(networkResponse(lastPage))
 
-      const result = await fetchBlockTransactions(config, 100)
+      const result = await fetchBlockTransactions(context, 100)
 
       expect(result).toHaveLength(1002)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
@@ -1031,11 +1030,11 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTxItem(i + 1))
       mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
-      const result = await fetchBlockTransactions(config, 100)
+      const result = await fetchBlockTransactions(context, 100)
 
       expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
-      expect(mockedLog).toHaveBeenCalledWith(
+      expect(mockLogger).toHaveBeenCalledWith(
         'tezos',
         expect.stringContaining('fetchBlockTransactions: maxTxQuery limit reached at level 100')
       )
@@ -1051,7 +1050,7 @@ describe('tzkt network API', () => {
     it('returns an empty array when the first page is empty', async () => {
       mockedNetwork.mockReturnValue(networkResponse([]))
 
-      const result = await fetchBlockTokenTransfers(config, 100)
+      const result = await fetchBlockTokenTransfers(context, 100)
 
       expect(result).toEqual([])
     })
@@ -1060,7 +1059,7 @@ describe('tzkt network API', () => {
       const items = [makeTokenItem(1), makeTokenItem(2)]
       mockedNetwork.mockReturnValue(networkResponse(items))
 
-      const result = await fetchBlockTokenTransfers(config, 100)
+      const result = await fetchBlockTokenTransfers(context, 100)
 
       expect(result).toEqual(items)
     })
@@ -1073,7 +1072,7 @@ describe('tzkt network API', () => {
         .mockReturnValueOnce(networkResponse(fullPage))
         .mockReturnValueOnce(networkResponse(lastPage))
 
-      const result = await fetchBlockTokenTransfers(config, 100)
+      const result = await fetchBlockTokenTransfers(context, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
@@ -1088,11 +1087,11 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeTokenItem(i + 1))
       mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
-      const result = await fetchBlockTokenTransfers(config, 100)
+      const result = await fetchBlockTokenTransfers(context, 100)
 
       expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
-      expect(mockedLog).toHaveBeenCalledWith(
+      expect(mockLogger).toHaveBeenCalledWith(
         'tezos',
         expect.stringContaining('fetchBlockTokenTransfers: maxTxQuery limit reached at level 100')
       )
@@ -1147,7 +1146,7 @@ describe('tzkt network API', () => {
     it('returns an empty array when the first page is empty', async () => {
       mockedNetwork.mockReturnValue(networkResponse([]))
 
-      const result = await fetchBlockDelegations(config, 100)
+      const result = await fetchBlockDelegations(context, 100)
 
       expect(result).toEqual([])
     })
@@ -1156,7 +1155,7 @@ describe('tzkt network API', () => {
       const items = [makeDelegationItem(1), makeDelegationItem(2)]
       mockedNetwork.mockReturnValue(networkResponse(items))
 
-      const result = await fetchBlockDelegations(config, 100)
+      const result = await fetchBlockDelegations(context, 100)
 
       expect(result).toEqual(items)
     })
@@ -1169,7 +1168,7 @@ describe('tzkt network API', () => {
         .mockReturnValueOnce(networkResponse(fullPage))
         .mockReturnValueOnce(networkResponse(lastPage))
 
-      const result = await fetchBlockDelegations(config, 100)
+      const result = await fetchBlockDelegations(context, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
@@ -1184,11 +1183,11 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeDelegationItem(i + 1))
       mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
-      const result = await fetchBlockDelegations(config, 100)
+      const result = await fetchBlockDelegations(context, 100)
 
       expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
-      expect(mockedLog).toHaveBeenCalledWith(
+      expect(mockLogger).toHaveBeenCalledWith(
         'tezos',
         expect.stringContaining('fetchBlockDelegations: maxTxQuery limit reached at level 100')
       )
@@ -1243,7 +1242,7 @@ describe('tzkt network API', () => {
     it('returns an empty array when the first page is empty', async () => {
       mockedNetwork.mockReturnValue(networkResponse([]))
 
-      const result = await fetchBlockStaking(config, 100)
+      const result = await fetchBlockStaking(context, 100)
 
       expect(result).toEqual([])
     })
@@ -1252,7 +1251,7 @@ describe('tzkt network API', () => {
       const items = [makeStakingItem(1), makeStakingItem(2)]
       mockedNetwork.mockReturnValue(networkResponse(items))
 
-      const result = await fetchBlockStaking(config, 100)
+      const result = await fetchBlockStaking(context, 100)
 
       expect(result).toEqual(items)
     })
@@ -1265,7 +1264,7 @@ describe('tzkt network API', () => {
         .mockReturnValueOnce(networkResponse(fullPage))
         .mockReturnValueOnce(networkResponse(lastPage))
 
-      const result = await fetchBlockStaking(config, 100)
+      const result = await fetchBlockStaking(context, 100)
 
       expect(result).toHaveLength(1001)
       expect(mockedNetwork).toHaveBeenCalledTimes(2)
@@ -1280,11 +1279,11 @@ describe('tzkt network API', () => {
       const fullPage = Array.from({ length: 1000 }, (_, i) => makeStakingItem(i + 1))
       mockedNetwork.mockReturnValue(networkResponse(fullPage))
 
-      const result = await fetchBlockStaking(config, 100)
+      const result = await fetchBlockStaking(context, 100)
 
       expect(mockedNetwork).toHaveBeenCalledTimes(100)
       expect(result).toHaveLength(100_000)
-      expect(mockedLog).toHaveBeenCalledWith(
+      expect(mockLogger).toHaveBeenCalledWith(
         'tezos',
         expect.stringContaining('fetchBlockStaking: maxTxQuery limit reached at level 100')
       )

package/src/network/tzkt.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig } from '../config'
+import type { TezosCoinConfig, TezosContext } from '../config'
 import type {
   APIAccount,
   APIBlock,
@@ -19,7 +19,6 @@ import type {
 } from './types'
 import URL from 'url'
 import network from '@ledgerhq/live-network'
-import { log } from '@ledgerhq/logs'
 
 /** TzKT hard-caps `limit` at 10 000; we use a safer page size to stay well under that. */
 const BLOCK_PAGE_SIZE = 1000
@@ -466,10 +465,11 @@ export type TzktApi = ReturnType<typeof createTzktApi>
 
 // TODO this has same purpose as api/listOperations
 export const fetchAllTransactions = async (
-  config: TezosCoinConfig,
+  context: TezosContext,
   address: string,
   lastId?: number
 ): Promise<APIOperation[]> => {
+  const config = await context.config()
   const api = createTzktApi(config)
   let ops: APIOperation[] = []
   let maxIteration = config.explorer.maxTxQuery
@@ -485,7 +485,7 @@ export const fetchAllTransactions = async (
     if (!last) return ops
     lastId = last.id
     if (!lastId) {
-      log('tezos', 'id missing!')
+      context.logger('tezos', 'id missing!')
       return ops
     }
   } while (--maxIteration)
@@ -500,11 +500,13 @@ export const fetchAllTransactions = async (
  * A safety cap (`maxTxQuery`) prevents infinite loops on pathological responses.
  */
 async function fetchBlockPaginated<T extends { id: number }>(
-  config: TezosCoinConfig,
-  pageFn: (level: number, cursor?: number) => Promise<T[]>,
+  context: TezosContext,
+  pageFnFactory: (config: TezosCoinConfig) => (level: number, cursor?: number) => Promise<T[]>,
   level: number,
   label: string
 ): Promise<T[]> {
+  const config = await context.config()
+  const pageFn = pageFnFactory(config)
   const items: T[] = []
   let cursor: number | undefined
   let maxIteration = config.explorer.maxTxQuery
@@ -516,45 +518,58 @@ async function fetchBlockPaginated<T extends { id: number }>(
     cursor = page.at(-1)!.id
   } while (--maxIteration > 0)
   if (maxIteration === 0) {
-    log('tezos', `${label}: maxTxQuery limit reached at level ${level}, result may be incomplete`)
+    context.logger(
+      'tezos',
+      `${label}: maxTxQuery limit reached at level ${level}, result may be incomplete`
+    )
   }
   return items
 }
 
-export const fetchBlockTransactions = (config: TezosCoinConfig, level: number) =>
+export const fetchBlockTransactions = (context: TezosContext, level: number) =>
   fetchBlockPaginated(
-    config,
-    createTzktApi(config).getBlockTransactionsPage,
+    context,
+    (config) => createTzktApi(config).getBlockTransactionsPage,
     level,
     'fetchBlockTransactions'
   )
 
-export const fetchBlockTokenTransfers = (config: TezosCoinConfig, level: number) =>
+export const fetchBlockTokenTransfers = (context: TezosContext, level: number) =>
   fetchBlockPaginated(
-    config,
-    createTzktApi(config).getBlockTokenTransfersPage,
+    context,
+    (config) => createTzktApi(config).getBlockTokenTransfersPage,
     level,
     'fetchBlockTokenTransfers'
   )
 
-export const fetchBlockDelegations = (config: TezosCoinConfig, level: number) =>
+export const fetchBlockDelegations = (context: TezosContext, level: number) =>
   fetchBlockPaginated(
-    config,
-    createTzktApi(config).getBlockDelegationsPage,
+    context,
+    (config) => createTzktApi(config).getBlockDelegationsPage,
     level,
     'fetchBlockDelegations'
   )
 
-export const fetchBlockStaking = (config: TezosCoinConfig, level: number) =>
-  fetchBlockPaginated(config, createTzktApi(config).getBlockStakingPage, level, 'fetchBlockStaking')
+export const fetchBlockStaking = (context: TezosContext, level: number) =>
+  fetchBlockPaginated(
+    context,
+    (config) => createTzktApi(config).getBlockStakingPage,
+    level,
+    'fetchBlockStaking'
+  )
 
-export const fetchBlockOriginations = (config: TezosCoinConfig, level: number) =>
+export const fetchBlockOriginations = (context: TezosContext, level: number) =>
   fetchBlockPaginated(
-    config,
-    createTzktApi(config).getBlockOriginationsPage,
+    context,
+    (config) => createTzktApi(config).getBlockOriginationsPage,
     level,
     'fetchBlockOriginations'
   )
 
-export const fetchBlockReveals = (config: TezosCoinConfig, level: number) =>
-  fetchBlockPaginated(config, createTzktApi(config).getBlockRevealsPage, level, 'fetchBlockReveals')
+export const fetchBlockReveals = (context: TezosContext, level: number) =>
+  fetchBlockPaginated(
+    context,
+    (config) => createTzktApi(config).getBlockRevealsPage,
+    level,
+    'fetchBlockReveals'
+  )

package/src/types/errors.ts

@@ -59,3 +59,10 @@ export class TezosStakeBlockedByPendingUnstake extends Error {
     this.name = 'TezosStakeBlockedByPendingUnstake'
   }
 }
+
+export class TezosStakeAmountTooSmall extends Error {
+  constructor() {
+    super('Stake amount too small to mint any staking pseudotoken')
+    this.name = 'TezosStakeAmountTooSmall'
+  }
+}

package/src/utils.ts

@@ -20,6 +20,38 @@ export const DUST_MARGIN_MUTEZ = 500
 // Tezos rejects `empty_implicit_delegated_contract`; stake-max leaves this buffer.
 export const STAKE_USE_ALL_RESERVE_MUTEZ = 10_000n
 
+/**
+ * Amount pre-estimated for a stake whose real amount isn't known yet (stake-max), and the floor
+ * a resolved stake-max must clear: only the probe is simulated, never the resolved amount.
+ *
+ * Octez rejects a stake that mints no pseudotoken (`stake_amount_too_small`): issued
+ * pseudotokens are `floor(amount * pseudotokens / staked_tez)`, so 1 mutez fails for any
+ * delegate whose stakers accrued rewards — a 2 mutez floor across delegates in 2026-09.
+ * https://gitlab.com/tezos/tezos/-/commit/b8339f8893e1da45e73ea5c4b1b82a0dfefb503c
+ */
+export const STAKE_ESTIMATION_PROBE_MUTEZ = 1_000n
+
+/**
+ * Suffixes of the protocol error ids `validateIntent` turns into field errors. Estimation reports
+ * these as `taquitoError` and the api returns them, so the mapping gets its turn instead of the
+ * raw id reaching the user. Any other protocol error keeps propagating — callers retry on it.
+ */
+export const MAPPED_TAQUITO_ERRORS = [
+  'balance_too_low',
+  'cannot_stake_with_unfinalizable_unstake_requests_to_another_delegate',
+  'contract.must_be_delegated_to_stake',
+  'delegate.unchanged',
+  'empty_implicit_contract',
+  'script_rejected',
+  'stake_amount_too_small',
+  'staking.too_much_unstaked',
+  'subtraction_underflow',
+]
+
+export function isMappedTaquitoError(id: string): boolean {
+  return MAPPED_TAQUITO_ERRORS.some((mapped) => id.endsWith(mapped))
+}
+
 /** Stake "Use Max": staked and unstaked-frozen funds count toward `balance` but aren't (re-)stakeable until finalized, so subtract both. */
 export function computeMaxStakeAmount(
   balance: bigint,