@ledgerhq/coin-tezos 10.2.1 → 10.2.4

package/src/logic/estimateRevealLimits.ts

@@ -1,9 +1,8 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosConfig } from '../config'
+import type { TezosContext } from '../config'
 import type { getTezosToolkit } from './tezosToolkit'
-import { log } from '@ledgerhq/logs'
 import { getRevealFee, getRevealGasLimit } from '@taquito/taquito'
 
 type RevealLimits = { fee: number; gasLimit: number; storageLimit: number }
@@ -14,19 +13,24 @@ type RevealLimits = { fee: number; gasLimit: number; storageLimit: number }
  * (some addresses error with "inconsistent_hash").
  */
 export async function estimateRevealLimits(
+  context: TezosContext,
   tezosToolkit: ReturnType<typeof getTezosToolkit>,
-  address: string,
-  feesConfig: TezosConfig['fees']
+  address: string
 ): Promise<RevealLimits> {
+  const { fees: feesConfig } = await context.config()
   type RevealEstimate = { gasLimit?: number; storageLimit?: number; suggestedFeeMutez?: number }
   let revealEstimate: RevealEstimate | undefined
   try {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     revealEstimate = (await tezosToolkit.estimate.reveal()) as RevealEstimate | undefined
   } catch (error) {
-    log('estimate-error', 'error estimating reveal fees, trying to use getRevealGasLimit', {
-      error,
-    })
+    context.logger(
+      'estimate-error',
+      'error estimating reveal fees, trying to use getRevealGasLimit',
+      {
+        error,
+      }
+    )
     revealEstimate = {
       gasLimit: getRevealGasLimit(address),
       suggestedFeeMutez: getRevealFee(address),

package/src/logic/getBalance.ts

@@ -3,7 +3,6 @@
 
 import type { TezosContext } from '../config'
 import type { Balance } from '@ledgerhq/coin-module-framework/api/index'
-import { log } from '@ledgerhq/logs'
 import { hasManagerKey } from '../network/types'
 import { createTzktApi } from '../network/tzkt'
 import { partitionNativeBalance } from '../utils'
@@ -60,14 +59,18 @@ export async function getBalance(context: TezosContext, address: string): Promis
   const normalized = BigInt(apiAccount.balance)
 
   const unstakeRequests = await fetchUnstakeRequests(config, address, apiAccount).catch((error) => {
-    log('coin:tezos', 'getBalance: fetchUnstakeRequests failed; degrading stakes to []', {
-      error,
-      address,
-    })
+    context.logger(
+      'coin:tezos',
+      'getBalance: fetchUnstakeRequests failed; degrading stakes to []',
+      {
+        error,
+        address,
+      }
+    )
     return []
   })
 
-  const stakes = buildStakesForAccount(address, apiAccount, unstakeRequests)
+  const stakes = buildStakesForAccount(context.logger, address, apiAccount, unstakeRequests)
   const stakedBalance = BigInt(apiAccount.stakedBalance ?? 0)
   const unstakedBalance = BigInt(apiAccount.unstakedBalance ?? 0)
   const { locked } = partitionNativeBalance(normalized, stakedBalance, unstakedBalance)

package/src/logic/getBlock.ts

@@ -534,12 +534,12 @@ export async function getBlock(context: TezosContext, height: number): Promise<B
   ] = await Promise.all([
     tzkt.getBlockByLevel(height),
     tzkt.getBlockByLevel(height - 1),
-    fetchBlockTransactions(config, height),
-    fetchBlockTokenTransfers(config, height),
-    fetchBlockDelegations(config, height),
-    fetchBlockStaking(config, height),
-    fetchBlockOriginations(config, height),
-    fetchBlockReveals(config, height),
+    fetchBlockTransactions(context, height),
+    fetchBlockTokenTransfers(context, height),
+    fetchBlockDelegations(context, height),
+    fetchBlockStaking(context, height),
+    fetchBlockOriginations(context, height),
+    fetchBlockReveals(context, height),
   ])
 
   // Token transfers triggered by originations from other blocks carry an

package/src/logic/getStakes.ts

@@ -4,7 +4,7 @@
 import type { TezosCoinConfig, TezosContext } from '../config'
 import type { APIAccount, APIManagerAccount, APIUnstakeRequest } from '../network/types'
 import type { Cursor, Page, Stake } from '@ledgerhq/coin-module-framework/api/types'
-import { log } from '@ledgerhq/logs'
+import type { Logger } from '@ledgerhq/coin-module-framework/config'
 import { hasManagerKey } from '../network/types'
 import { createTzktApi } from '../network/tzkt'
 import { partitionNativeBalance } from '../utils'
@@ -28,17 +28,21 @@ export function fetchUnstakeRequests(
     : Promise.resolve([])
 }
 
-function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake | null {
+function unstakeRequestToStake(
+  logger: Logger,
+  address: string,
+  req: APIUnstakeRequest
+): Stake | null {
   // TzKT's status filter is unreliable; never build a position for a finalized request.
   if (req.status !== 'pending' && req.status !== 'finalizable') {
-    log('coin:tezos', 'unstakeRequestToStake: dropping non-active unstake request', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping non-active unstake request', {
       requestId: req.id,
       status: req.status,
     })
     return null
   }
   if (req.actualAmount <= 0) {
-    log('coin:tezos', 'unstakeRequestToStake: dropping non-positive unstake request', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping non-positive unstake request', {
       requestId: req.id,
       actualAmount: req.actualAmount,
     })
@@ -46,7 +50,7 @@ function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake |
   }
   const createdAt = new Date(req.firstTime)
   if (!Number.isFinite(createdAt.getTime())) {
-    log('coin:tezos', 'unstakeRequestToStake: dropping unstake request with invalid firstTime', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping unstake request with invalid firstTime', {
       requestId: req.id,
       firstTime: req.firstTime,
     })
@@ -67,6 +71,7 @@ function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake |
 }
 
 export function buildStakesForAccount(
+  logger: Logger,
   address: string,
   account: APIManagerAccount,
   unstakeRequests: APIUnstakeRequest[]
@@ -80,7 +85,7 @@ export function buildStakesForAccount(
 
   const unstakeStakes: Stake[] = []
   for (const req of unstakeRequests) {
-    const stake = unstakeRequestToStake(address, req)
+    const stake = unstakeRequestToStake(logger, address, req)
     if (stake) unstakeStakes.push(stake)
   }
 
@@ -93,7 +98,7 @@ export function buildStakesForAccount(
       unstakedBalance
     )
     if (locked < stakedBalance + unstakedBalance) {
-      log('coin:tezos', 'buildStakesForAccount: balance < staked + unstaked, clamping to 0', {
+      logger('coin:tezos', 'buildStakesForAccount: balance < staked + unstaked, clamping to 0', {
         address,
         balance: balance.toString(),
         stakedBalance: stakedBalance.toString(),
@@ -137,5 +142,5 @@ export async function getStakes(
   const accountInfo = await createTzktApi(config).getAccountByAddress(address)
   if (!hasManagerKey(accountInfo)) return { items: [] }
   const unstakeRequests = await fetchUnstakeRequests(config, address, accountInfo)
-  return { items: buildStakesForAccount(address, accountInfo, unstakeRequests) }
+  return { items: buildStakesForAccount(context.logger, address, accountInfo, unstakeRequests) }
 }

package/src/logic/listOperations.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig, TezosContext } from '../config'
+import type { TezosContext } from '../config'
 import type { AccountsGetOperationsOptions } from '../network/types'
 import type {
   APIDelegationType,
@@ -14,7 +14,7 @@ import type {
   TokenTransfersGetOptions,
 } from '../network/types'
 import type { Operation } from '@ledgerhq/coin-module-framework/api/types'
-import { log } from '@ledgerhq/logs'
+import type { Logger } from '@ledgerhq/coin-module-framework/config'
 import { STAKING_ACTION_TO_OP_TYPE } from '../constants'
 import { createTzktApi } from '../network'
 import {
@@ -69,6 +69,7 @@ function maxLevel<T extends { level: number }>(items: T[]): number | undefined {
 
 /** When the API returned a full page, the trailing block level may be incomplete — drop it. */
 function trimPartialLastLevel<T extends { level: number; id: number }>(
+  logger: Logger,
   items: T[],
   full: boolean
 ): { trimmed: T[]; intraLevelLastId?: number } {
@@ -78,7 +79,7 @@ function trimPartialLastLevel<T extends { level: number; id: number }>(
   const lastLevel = last.level
   const filtered = items.filter((op) => op.level !== lastLevel)
   if (filtered.length === 0) {
-    log('coin:tezos', 'listOperations: full page single level — keeping all rows', {
+    logger('coin:tezos', 'listOperations: full page single level — keeping all rows', {
       lastLevel,
       count: items.length,
     })
@@ -251,6 +252,7 @@ function keepNativeOp(op: APIOperation, address: string): op is ConvertibleOpera
 }
 
 function convertNativeOps(
+  logger: Logger,
   ops: APIOperation[],
   address: string,
   stakingBlockHashes: Map<number, string>
@@ -282,7 +284,7 @@ function convertNativeOps(
   return ops
     .filter((op): op is ConvertibleOperation => keepNativeOp(op, address))
     .map((op) => {
-      const converted = convertOperation(address, op, stakingBlockHashes)
+      const converted = convertOperation(logger, address, op, stakingBlockHashes)
       const extraFee = internalFeesByHash.get(converted.tx.hash)
       if (extraFee) {
         // Add internal sub-tx fees to the parent operation, then clear to avoid
@@ -368,8 +370,8 @@ export async function listOperations(
   const nativePage = clampPage(nativeOpsRaw, limit)
   const tokenPage = clampPage(tokenTransfersRaw, limit)
 
-  const nativeTrimmed = trimPartialLastLevel(nativePage.sliced, nativePage.full)
-  const tokenTrimmed = trimPartialLastLevel(tokenPage.sliced, tokenPage.full)
+  const nativeTrimmed = trimPartialLastLevel(context.logger, nativePage.sliced, nativePage.full)
+  const tokenTrimmed = trimPartialLastLevel(context.logger, tokenPage.sliced, tokenPage.full)
 
   // when both streams are exhausted (neither hit the page limit),
   // we already have every op — alignment would silently discard ops
@@ -388,7 +390,7 @@ export async function listOperations(
       ? tokenTrimmed.trimmed
       : alignToBoundary(tokenTrimmed.trimmed, boundary, sort)
 
-  const stakingBlockHashes = await fetchMissingStakingBlockHashes(config, nativeAligned)
+  const stakingBlockHashes = await fetchMissingStakingBlockHashes(context, nativeAligned)
 
   const parentMap = buildParentMap(nativeAligned)
 
@@ -401,7 +403,12 @@ export async function listOperations(
     tokenTrimmed.intraLevelLastId
   )
 
-  const filteredNativeOps = convertNativeOps(nativeAligned, address, stakingBlockHashes)
+  const filteredNativeOps = convertNativeOps(
+    context.logger,
+    nativeAligned,
+    address,
+    stakingBlockHashes
+  )
   const tokenConverted = convertTokenOps(tokenAligned, parentMap, address)
 
   const sortedOperations = [...filteredNativeOps, ...tokenConverted].sort(
@@ -424,7 +431,7 @@ type ConvertibleOperation =
  * failures are swallowed: callers fall back to `""` for levels not in the map.
  */
 async function fetchMissingStakingBlockHashes(
-  config: TezosCoinConfig,
+  context: TezosContext,
   ops: readonly APIOperation[]
 ): Promise<Map<number, string>> {
   const missingLevels = new Set<number>()
@@ -432,10 +439,11 @@ async function fetchMissingStakingBlockHashes(
     if (isAPIStakingType(op) && !op.block) missingLevels.add(op.level)
   }
   if (missingLevels.size === 0) return new Map()
+  const config = await context.config()
   try {
     return await createTzktApi(config).getBlockHashesByLevels([...missingLevels])
   } catch (err) {
-    log('coin:tezos', 'fetchMissingStakingBlockHashes: skipped on fetch error', {
+    context.logger('coin:tezos', 'fetchMissingStakingBlockHashes: skipped on fetch error', {
       reason: String(err),
     })
     return new Map()
@@ -487,6 +495,7 @@ function resolveAmount(operation: ConvertibleOperation): bigint {
 }
 
 function resolveNormalizedType(
+  logger: Logger,
   operation: ConvertibleOperation,
   address: string,
   targetAddress: string | undefined,
@@ -499,7 +508,7 @@ function resolveNormalizedType(
   if (isAPIRevealType(operation)) return 'REVEAL'
   if (isAPIOriginationType(operation)) return operation.contractBalance > 0 ? 'OUT' : 'FEES'
   if (!isAPITransactionType(operation)) {
-    log('coin:tezos', '(logic/operations): Unknown operation type, defaulting to OUT')
+    logger('coin:tezos', '(logic/operations): Unknown operation type, defaulting to OUT')
     return 'OUT'
   }
   const isOut = operation.sender?.address === address
@@ -529,6 +538,7 @@ function getLedgerOpType(
 }
 
 function convertOperation(
+  logger: Logger,
   address: string,
   operation: ConvertibleOperation,
   stakingBlockHashes: Map<number, string>
@@ -544,7 +554,7 @@ function convertOperation(
   const targetAddress = resolveTargetAddress(operation)
   // reveal has no meaningful target; staking resolves senders/recipients separately.
   if (!targetAddress && !isAPIRevealType(operation) && !isAPIStakingType(operation)) {
-    log('coin:tezos', '(logic/operations): No target address found for operation', operation)
+    logger('coin:tezos', '(logic/operations): No target address found for operation', operation)
   }
 
   const { senders, recipients } = isAPIStakingType(operation)
@@ -561,7 +571,7 @@ function convertOperation(
     BigInt(operation.bakerFee ?? 0) +
     BigInt(operation.allocationFee ?? 0)
 
-  const normalizedType = resolveNormalizedType(operation, address, targetAddress, amount)
+  const normalizedType = resolveNormalizedType(logger, operation, address, targetAddress, amount)
 
   // Tezos uses "applied" for every success operation (something else=failed )
   const hasFailed = operation.status && operation.status !== 'applied'

package/src/logic/validateIntent.test.ts

@@ -8,15 +8,17 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
   NotEnoughBalance,
+  UnexpectedGetBalanceError,
 } from '@ledgerhq/coin-module-framework/errors'
 import {
   InvalidAddressBecauseAlreadyDelegated,
   MustDelegateBeforeStaking,
   NotEnoughBalanceToDelegate,
   TezosNotEnoughStaked,
+  TezosStakeAmountTooSmall,
   TezosStakeBlockedByPendingUnstake,
 } from '../types/errors'
-import { STAKE_USE_ALL_RESERVE_MUTEZ } from '../utils'
+import { MAPPED_TAQUITO_ERRORS, STAKE_USE_ALL_RESERVE_MUTEZ } from '../utils'
 import { validateIntent } from './validateIntent'
 
 const mockEstimateFees = jest.fn()
@@ -386,6 +388,35 @@ describe('validateIntent', () => {
       expect(result.amount).toBe(0n)
     })
 
+    it('should return TezosStakeAmountTooSmall when stake useAllAmount resolves max below the probe', async () => {
+      mockGetAccountByAddress.mockResolvedValue(
+        makeUserAccount({
+          delegate: { alias: 'baker', address: validRecipient, active: true },
+          delegationLevel: 1,
+        })
+      )
+      mockEstimateFees.mockResolvedValueOnce({
+        fees: 1000n,
+        gasLimit: 10000n,
+        storageLimit: 0n,
+        estimatedFees: 1000n,
+        amount: 999n,
+      })
+
+      const result = await validateIntent(context, {
+        intentType: 'staking',
+        asset: { type: 'native' },
+        type: 'stake',
+        sender: senderAddress,
+        recipient: '',
+        amount: 0n,
+        useAllAmount: true,
+      })
+
+      expect(result.errors.amount).toBeInstanceOf(TezosStakeAmountTooSmall)
+      expect(result.amount).toBe(999n)
+    })
+
     it('excludes already-staked funds when stake useAllAmount falls back to balance computation', async () => {
       mockGetAccountByAddress.mockResolvedValue(
         makeUserAccount({
@@ -986,6 +1017,65 @@ describe('validateIntent', () => {
       expect(result.errors.amount).toBeInstanceOf(MustDelegateBeforeStaking)
     })
 
+    it('maps stake_amount_too_small to TezosStakeAmountTooSmall', async () => {
+      mockGetAccountByAddress.mockResolvedValue(
+        makeUserAccount({
+          delegate: { alias: 'baker', address: validRecipient, active: true },
+          delegationLevel: 1,
+        })
+      )
+      mockEstimateFees.mockResolvedValue({
+        fees: 0n,
+        gasLimit: 0n,
+        storageLimit: 0n,
+        estimatedFees: 500n,
+        taquitoError: 'proto.025-PsUshuai.block_validation_plugin.stake_amount_too_small',
+      })
+
+      const result = await validateIntent(context, {
+        intentType: 'staking',
+        asset: { type: 'native' },
+        type: 'stake',
+        sender: senderAddress,
+        recipient: '',
+        amount: 1n,
+      })
+
+      expect(result.errors.amount).toBeInstanceOf(TezosStakeAmountTooSmall)
+    })
+
+    it.each(MAPPED_TAQUITO_ERRORS)(
+      'maps %s, which estimation reports instead of throwing, to a dedicated error',
+      async (id) => {
+        mockGetAccountByAddress.mockResolvedValue(
+          makeUserAccount({
+            delegate: { alias: 'baker', address: validRecipient, active: true },
+            delegationLevel: 1,
+          })
+        )
+        mockEstimateFees.mockResolvedValue({
+          fees: 0n,
+          gasLimit: 0n,
+          storageLimit: 0n,
+          estimatedFees: 500n,
+          taquitoError: `proto.025-PsUshuai.${id}`,
+        })
+
+        const result = await validateIntent(context, {
+          intentType: 'staking',
+          asset: { type: 'native' },
+          type: 'stake',
+          sender: senderAddress,
+          recipient: '',
+          amount: 1000n,
+        })
+
+        const error = result.errors.amount ?? result.errors.recipient
+        expect(error).toBeInstanceOf(Error)
+        expect(error?.name).not.toBe('Error')
+      }
+    )
+
     it('maps cannot_stake_with_unfinalizable_unstake_requests_to_another_delegate to TezosStakeBlockedByPendingUnstake for stake', async () => {
       mockGetAccountByAddress.mockResolvedValue(
         makeUserAccount({
@@ -1163,7 +1253,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([])
 
@@ -1179,6 +1269,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 () => {
@@ -1577,6 +1774,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', () => {