@ledgerhq/coin-tezos 10.2.0 → 10.2.2

package/src/logic/validateIntent.test.ts

@@ -1,14 +1,14 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig, TezosContext } from '../config'
-import type { TransactionIntent } from '@ledgerhq/coin-module-framework/api/types'
+import type { TezosContext } from '../config'
 import {
   RecipientRequired,
   InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
   NotEnoughBalance,
+  UnexpectedGetBalanceError,
 } from '@ledgerhq/coin-module-framework/errors'
 import {
   InvalidAddressBecauseAlreadyDelegated,
@@ -57,20 +57,19 @@ describe('validateIntent', () => {
   })
 
   const context: TezosContext = {
-    config: async () =>
-      ({
-        status: { type: 'active' },
-        baker: { url: 'http://baker.example.com' },
-        explorer: { url: 'http://tezos.explorer.com', maxTxQuery: 100 },
-        node: { url: 'http://tezos.node.com' },
-        fees: {
-          minGasLimit: 600,
-          minRevealGasLimit: 300,
-          minStorageLimit: 0,
-          minFees: 500,
-          minEstimatedFees: 500,
-        },
-      }) as unknown as TezosCoinConfig,
+    config: async () => ({
+      status: { type: 'active' },
+      baker: { url: 'http://baker.example.com' },
+      explorer: { url: 'http://tezos.explorer.com', maxTxQuery: 100 },
+      node: { url: 'http://tezos.node.com' },
+      fees: {
+        minGasLimit: 600,
+        minRevealGasLimit: 300,
+        minStorageLimit: 0,
+        minFees: 500,
+        minEstimatedFees: 500,
+      },
+    }),
     logger: () => undefined,
   }
 
@@ -229,7 +228,7 @@ describe('validateIntent', () => {
         sender: senderAddress,
         recipient: '',
         amount: 0n,
-      } satisfies TransactionIntent)
+      })
 
       expect(result).toEqual({
         errors: {},
@@ -569,7 +568,7 @@ describe('validateIntent', () => {
         sender: senderAddress,
         recipient: '',
         amount: 0n,
-      } satisfies TransactionIntent)
+      })
 
       expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
       expect(mockEstimateFees).not.toHaveBeenCalled()
@@ -757,7 +756,7 @@ describe('validateIntent', () => {
         sender: senderAddress,
         recipient: '',
         amount: 0n,
-      } satisfies TransactionIntent)
+      })
 
       expect(result.errors).toEqual({})
     })
@@ -1165,7 +1164,7 @@ describe('validateIntent', () => {
       expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
     })
 
-    it('should set amount to 0n when useAllAmount and token balance row is missing', async () => {
+    it('should set amount to 0n and NotEnoughBalance when useAllAmount and token balance row is missing [LIVE-36768]', async () => {
       const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
       mockGetTokensBalances.mockResolvedValue([])
 
@@ -1181,6 +1180,113 @@ describe('validateIntent', () => {
 
       expect(result.amount).toBe(0n)
       expect(result.totalSpent).toBe(1000n)
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
+
+    it('send-max on a 0-balance token account blocks with NotEnoughBalance even when parent XTZ account has funds for fees [LIVE-36768]', async () => {
+      const contract = 'KT1XnTn74bagnxYoFErbDH5QRAULUDtpXkmV'
+
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ balance: 5_000_000 }))
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 2,
+          account: { address: senderAddress },
+          token: {
+            id: 2,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'USDt', decimals: '6' },
+          },
+          balance: '0',
+          transfersCount: 0,
+          firstLevel: 0,
+          firstTime: '',
+          lastLevel: 0,
+          lastTime: '',
+        },
+      ])
+
+      const result = await validateIntent(context, {
+        intentType: 'transaction',
+        asset: { type: 'token', assetReference: `${contract}:0` },
+        type: 'send',
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: 0n,
+        useAllAmount: true,
+      })
+
+      expect(result.amount).toBe(0n)
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
+
+    it('send-max on a token account with a positive balance still resolves with no error [LIVE-36768 regression guard]', async () => {
+      const contract = 'KT1XnTn74bagnxYoFErbDH5QRAULUDtpXkmV'
+      const tokenBalance = '10000'
+
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 2,
+          account: { address: senderAddress },
+          token: {
+            id: 2,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'USDt', decimals: '6' },
+          },
+          balance: tokenBalance,
+          transfersCount: 0,
+          firstLevel: 0,
+          firstTime: '',
+          lastLevel: 0,
+          lastTime: '',
+        },
+      ])
+
+      const result = await validateIntent(context, {
+        intentType: 'transaction',
+        asset: { type: 'token', assetReference: `${contract}:0` },
+        type: 'send',
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: 0n,
+        useAllAmount: true,
+      })
+
+      expect(result.errors.amount).toBeUndefined()
+      expect(result.amount).toBe(BigInt(tokenBalance))
+    })
+
+    it('send-max token: an unreachable TzKT blocks instead of returning the XTZ balance as a token amount [LIVE-36768]', async () => {
+      // The wrong-unit fallback: with no token balance, calculateAmounts returned
+      // spendable-XTZ-minus-fees (4_999_000 mutez) as the token amount, so the user could have
+      // signed a 4.999 USDt transfer they never chose.
+      const contract = 'KT1XnTn74bagnxYoFErbDH5QRAULUDtpXkmV'
+      const cause = new Error('TzKT unreachable')
+
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ balance: 5_000_000 }))
+      mockGetTokensBalances.mockRejectedValue(cause)
+
+      const result = await validateIntent(context, {
+        intentType: 'transaction',
+        asset: { type: 'token', assetReference: `${contract}:0` },
+        type: 'send',
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: 0n,
+        useAllAmount: true,
+      })
+
+      expect(result.amount).toBe(0n)
+      expect(result.amount).not.toBe(4_999_000n)
+      expect(result.estimatedFees).toBe(1000n) // fee estimation is preserved, not wiped
+      // A holder of the token must not be told they have insufficient funds.
+      const amountError: Error = result.errors.amount
+      expect(amountError).toBeInstanceOf(UnexpectedGetBalanceError)
+      expect(amountError).not.toBeInstanceOf(NotEnoughBalance)
+      expect(amountError).toHaveProperty('cause', cause)
     })
 
     it('fixed-amount TKEY (18 dec): no error when user has enough token and XTZ for fees [LIVE-35976]', async () => {
@@ -1579,6 +1685,25 @@ describe('validateIntent', () => {
       expect(result.amount).toBe(1_999_000n)
       expect(result.totalSpent).toBe(2_000_000n)
     })
+
+    it('blocks native send-max when spendable balance is exactly the fees [LIVE-36768]', async () => {
+      // The native counterpart: totalSpent equals spendable exactly, so the
+      // `totalSpent > spendable` coverage check passes and a 0-XTZ send used to go through.
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ balance: 1000 })) // == estimatedFees
+
+      const result = await validateIntent(context, {
+        intentType: 'transaction',
+        asset: { type: 'native' },
+        type: 'send',
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: 0n,
+        useAllAmount: true,
+      })
+
+      expect(result.amount).toBe(0n)
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
   })
 
   describe('successful validation', () => {

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'
@@ -397,17 +398,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,7 +428,22 @@ 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()
     }
 
@@ -431,8 +455,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' &&
@@ -444,7 +468,7 @@ export async function validateIntent(
       }
     }
   } catch (e) {
-    errors.estimation = e as Error
+    errors.estimation = e instanceof Error ? e : new Error(String(e))
     estimatedFees = 0n
     amount = intent.amount
     totalSpent = intent.amount

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

@@ -7,7 +7,7 @@ import whitelist from '../network/bakers.whitelist-default'
 import { mockConfig } from '../test/config'
 
 describe('tezos bakers', () => {
-  const config: TezosCoinConfig = mockConfig as TezosCoinConfig
+  const config: TezosCoinConfig = mockConfig
 
   test('atleast 10 whitelisted bakers are online', async () => {
     const onlineBakersCount = (await listBakers(config, whitelist))

package/src/network/bakers.test.ts

@@ -3,16 +3,18 @@
 
 import type { TezosCoinConfig } from '../config'
 import type { TezosApiBaker } from './bakers'
-import network from '@ledgerhq/live-network/network'
 import { mockConfig } from '../test/config'
 import { asBaker, cache } from './bakers'
 
-jest.mock('@ledgerhq/live-network/network')
-const mockedNetwork = jest.mocked(network)
+const mockNetworkFn = jest.fn()
+jest.mock('@ledgerhq/live-network/network', () => ({
+  __esModule: true,
+  default: (...args: unknown[]) => mockNetworkFn(...args),
+}))
 
 // `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 config: TezosCoinConfig = mockConfig
 
 const data: TezosApiBaker[] = [
   {
@@ -177,17 +179,7 @@ describe('Tezos Baker', () => {
 
   describe('Get bakers from cache', () => {
     beforeEach(() => {
-      const response = {
-        data,
-        status: 200,
-        headers: {} as any,
-        statusText: '',
-        config: {
-          headers: {} as any,
-        },
-      }
-
-      mockedNetwork.mockReturnValue(Promise.resolve(response))
+      mockNetworkFn.mockResolvedValue({ data })
     })
 
     it('Ledger Baker should be first in the list', async () => {

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

@@ -16,20 +16,19 @@ import { createTzktApi } from './tzkt'
 const MULTI_ASSET_HOLDER = 'tz1ZB8hpQJZdQeEPc3uG2cL1NXwLTPkqeAD6'
 const WRAPPED_CONTRACT = 'KT18fp5rcTW7mbWDmzFwjLDUhs5MeJmagDSZ'
 
-const mainnetConfig = (): TezosCoinConfig =>
-  ({
-    status: { type: 'active' },
-    baker: { url: 'https://tezos-bakers.api.live.ledger.com' },
-    explorer: { url: 'https://xtz-tzkt-explorer.api.vault.ledger.com', maxTxQuery: 100 },
-    node: { url: 'https://xtz-node.api.live.ledger.com' },
-    fees: {
-      minGasLimit: 0,
-      minRevealGasLimit: 0,
-      minStorageLimit: 0,
-      minFees: 0,
-      minEstimatedFees: 0,
-    },
-  }) as TezosCoinConfig
+const mainnetConfig = (): TezosCoinConfig => ({
+  status: { type: 'active' },
+  baker: { url: 'https://tezos-bakers.api.live.ledger.com' },
+  explorer: { url: 'https://xtz-tzkt-explorer.api.vault.ledger.com', maxTxQuery: 100 },
+  node: { url: 'https://xtz-node.api.live.ledger.com' },
+  fees: {
+    minGasLimit: 0,
+    minRevealGasLimit: 0,
+    minStorageLimit: 0,
+    minFees: 0,
+    minEstimatedFees: 0,
+  },
+})
 
 describe('TzKT multi-asset FA2 — mainnet', () => {
   const config: TezosCoinConfig = mainnetConfig()