@ledgerhq/coin-tezos 10.2.2 → 10.2.4

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,