@ledgerhq/coin-tezos 10.0.0 → 10.2.0

package/src/logic/getBalance.test.ts

@@ -3,10 +3,27 @@
 
 import type { TezosCoinConfig, TezosContext } from '../config'
 import type { APITokenBalance } from '../network/types'
-import { HttpResponse, http } from 'msw'
-import { setupServer } from 'msw/node'
 import { getBalance } from './getBalance'
 
+const mockedGetAccountByAddress = jest.fn()
+const mockedGetTokensBalances = jest.fn()
+const mockedGetUnstakeRequests = jest.fn()
+
+jest.mock('../network/tzkt', () => {
+  const originalModule = jest.requireActual('../network/tzkt')
+  return {
+    ...originalModule,
+    createTzktApi: () => {
+      return {
+        ...originalModule.api,
+        getAccountByAddress: mockedGetAccountByAddress,
+        getTokensBalances: mockedGetTokensBalances,
+        getUnstakeRequests: mockedGetUnstakeRequests,
+      }
+    },
+  }
+})
+
 const mockTokensBalancesWithAllInfo: APITokenBalance[] = [
   {
     id: 2398642347442177,
@@ -51,14 +68,8 @@ const mockTokensBalancesWithMissingInfo: APITokenBalance[] = [
 ]
 
 describe('getBalance', () => {
-  const mockServer = setupServer()
-
-  beforeAll(() => {
-    mockServer.listen({ onUnhandledRequest: 'error' })
-  })
-
-  afterAll(() => {
-    mockServer.close()
+  beforeEach(() => {
+    jest.resetAllMocks()
   })
 
   const context: TezosContext = {
@@ -70,35 +81,31 @@ describe('getBalance', () => {
     logger: () => undefined,
   }
   it('gets the balance of a Tezos account', async () => {
-    mockServer.use(
-      http.get('http://tezos.explorer.com/v1/accounts/tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq', () =>
-        HttpResponse.json({ type: 'empty' })
-      ),
-      http.get('http://tezos.explorer.com/v1/accounts/tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8', () =>
-        HttpResponse.json({ type: 'user', balance: 25 })
-      ),
-      http.get('http://tezos.explorer.com/v1/accounts/tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oMMM', () =>
-        HttpResponse.json({
+    mockedGetAccountByAddress.mockImplementation((address: string) => {
+      if (address === 'tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq') {
+        return { type: 'empty' }
+      } else if (address === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8') {
+        return { type: 'user', balance: 25 }
+      } else if (address === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oMMM') {
+        return {
           type: 'user',
           balance: 15,
           delegate: { address: 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oMMM' },
-        })
-      ),
-      http.get('http://tezos.explorer.com/v1/tokens/balances', ({ request }) => {
-        const url = new URL(request.url)
-        const account = url.searchParams.get('account')
-
-        // Return a mocked JSON response when the "account"
-        // search parameter equals a specific address.
-        if (account === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8') {
-          return HttpResponse.json(mockTokensBalancesWithAllInfo)
-        } else if (account === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oMMM') {
-          return HttpResponse.json(mockTokensBalancesWithMissingInfo)
-        } else {
-          return HttpResponse.json([])
         }
-      })
-    )
+      } else {
+        throw new Error('address not handled by the test: ' + address)
+      }
+    })
+
+    mockedGetTokensBalances.mockImplementation((address: string) => {
+      if (address === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8') {
+        return mockTokensBalancesWithAllInfo
+      } else if (address === 'tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oMMM') {
+        return mockTokensBalancesWithMissingInfo
+      } else {
+        return []
+      }
+    })
 
     expect(await getBalance(context, 'tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq')).toEqual([
       {
@@ -164,15 +171,9 @@ describe('getBalance', () => {
     const delegateAddress = 'tz1BakerAddr'
 
     function mockAccount(account: Record<string, unknown>) {
-      mockServer.use(
-        http.get(`http://tezos.explorer.com/v1/accounts/${address}`, () =>
-          HttpResponse.json({ type: 'user', ...account })
-        ),
-        http.get('http://tezos.explorer.com/v1/tokens/balances', () => HttpResponse.json([])),
-        http.get('http://tezos.explorer.com/v1/staking/unstake_requests', () =>
-          HttpResponse.json([])
-        )
-      )
+      mockedGetAccountByAddress.mockResolvedValue({ type: 'user', ...account })
+      mockedGetTokensBalances.mockResolvedValue([])
+      mockedGetUnstakeRequests.mockResolvedValue([])
     }
 
     it('attaches a delegation Stake when only delegate is set', async () => {
@@ -271,31 +272,25 @@ describe('getBalance', () => {
     })
 
     it("attaches an unstaking Stake with state 'deactivating' when a pending request exists", async () => {
-      mockServer.use(
-        http.get(`http://tezos.explorer.com/v1/accounts/${address}`, () =>
-          HttpResponse.json({
-            type: 'user',
-            balance: 100,
-            stakedBalance: 30,
-            unstakedBalance: 10,
-            delegate: { address: delegateAddress },
-          })
-        ),
-        http.get('http://tezos.explorer.com/v1/staking/unstake_requests', () =>
-          HttpResponse.json([
-            {
-              id: 77,
-              cycle: 100,
-              baker: { address: delegateAddress },
-              staker: { address },
-              firstTime: '2026-05-01T00:00:00Z',
-              status: 'pending',
-              actualAmount: 10,
-            },
-          ])
-        ),
-        http.get('http://tezos.explorer.com/v1/tokens/balances', () => HttpResponse.json([]))
-      )
+      mockedGetAccountByAddress.mockResolvedValue({
+        type: 'user',
+        balance: 100,
+        stakedBalance: 30,
+        unstakedBalance: 10,
+        delegate: { address: delegateAddress },
+      })
+      mockedGetTokensBalances.mockResolvedValue([])
+      mockedGetUnstakeRequests.mockResolvedValue([
+        {
+          id: 77,
+          cycle: 100,
+          baker: { address: delegateAddress },
+          staker: { address },
+          firstTime: '2026-05-01T00:00:00Z',
+          status: 'pending',
+          actualAmount: 10,
+        },
+      ])
 
       const result = await getBalance(context, address)
 
@@ -318,39 +313,33 @@ describe('getBalance', () => {
     })
 
     it('emits per-request unstaking and finalizable Stakes when both statuses are present', async () => {
-      mockServer.use(
-        http.get(`http://tezos.explorer.com/v1/accounts/${address}`, () =>
-          HttpResponse.json({
-            type: 'user',
-            balance: 100,
-            unstakedBalance: 50,
-            delegate: { address: delegateAddress },
-          })
-        ),
-        http.get('http://tezos.explorer.com/v1/staking/unstake_requests', () =>
-          HttpResponse.json([
-            {
-              id: 1,
-              cycle: 100,
-              baker: { address: delegateAddress },
-              staker: { address },
-              firstTime: '2026-05-01T00:00:00Z',
-              status: 'pending',
-              actualAmount: 20,
-            },
-            {
-              id: 2,
-              cycle: 99,
-              baker: { address: delegateAddress },
-              staker: { address },
-              firstTime: '2026-04-25T00:00:00Z',
-              status: 'finalizable',
-              actualAmount: 30,
-            },
-          ])
-        ),
-        http.get('http://tezos.explorer.com/v1/tokens/balances', () => HttpResponse.json([]))
-      )
+      mockedGetAccountByAddress.mockResolvedValue({
+        type: 'user',
+        balance: 100,
+        unstakedBalance: 50,
+        delegate: { address: delegateAddress },
+      })
+      mockedGetUnstakeRequests.mockResolvedValue([
+        {
+          id: 1,
+          cycle: 100,
+          baker: { address: delegateAddress },
+          staker: { address },
+          firstTime: '2026-05-01T00:00:00Z',
+          status: 'pending',
+          actualAmount: 20,
+        },
+        {
+          id: 2,
+          cycle: 99,
+          baker: { address: delegateAddress },
+          staker: { address },
+          firstTime: '2026-04-25T00:00:00Z',
+          status: 'finalizable',
+          actualAmount: 30,
+        },
+      ])
+      mockedGetTokensBalances.mockResolvedValue([])
 
       const result = await getBalance(context, address)
 
@@ -396,30 +385,25 @@ describe('getBalance', () => {
       // A delegate has no `delegate` field (it is its own baker), so there is no delegation position —
       // only its self-stake and any unstake requests. The unstakedBalance > 0 exercises the
       // delegate → fetchUnstakeRequests path.
-      mockServer.use(
-        http.get(`http://tezos.explorer.com/v1/accounts/${address}`, () =>
-          HttpResponse.json({
-            type: 'delegate',
-            balance: 100,
-            stakedBalance: 30,
-            unstakedBalance: 10,
-          })
-        ),
-        http.get('http://tezos.explorer.com/v1/tokens/balances', () => HttpResponse.json([])),
-        http.get('http://tezos.explorer.com/v1/staking/unstake_requests', () =>
-          HttpResponse.json([
-            {
-              id: 77,
-              cycle: 100,
-              baker: { address },
-              staker: { address },
-              firstTime: '2026-05-01T00:00:00Z',
-              status: 'pending',
-              actualAmount: 10,
-            },
-          ])
-        )
-      )
+
+      mockedGetAccountByAddress.mockResolvedValue({
+        type: 'delegate',
+        balance: 100,
+        stakedBalance: 30,
+        unstakedBalance: 10,
+      })
+      mockedGetTokensBalances.mockResolvedValue([])
+      mockedGetUnstakeRequests.mockResolvedValue([
+        {
+          id: 77,
+          cycle: 100,
+          baker: { address },
+          staker: { address },
+          firstTime: '2026-05-01T00:00:00Z',
+          status: 'pending',
+          actualAmount: 10,
+        },
+      ])
 
       expect(await getBalance(context, address)).toEqual([
         { value: 100n, asset: { type: 'native' }, locked: 40n },
@@ -461,20 +445,14 @@ describe('getBalance', () => {
     })
 
     it('still excludes unstaked-frozen funds from spendable when the unstake_requests endpoint fails', async () => {
-      mockServer.use(
-        http.get(`http://tezos.explorer.com/v1/accounts/${address}`, () =>
-          HttpResponse.json({
-            type: 'user',
-            balance: 100,
-            unstakedBalance: 10,
-            delegate: { address: delegateAddress },
-          })
-        ),
-        http.get('http://tezos.explorer.com/v1/staking/unstake_requests', () =>
-          HttpResponse.json({ error: 'internal' }, { status: 500 })
-        ),
-        http.get('http://tezos.explorer.com/v1/tokens/balances', () => HttpResponse.json([]))
-      )
+      mockedGetAccountByAddress.mockResolvedValue({
+        type: 'user',
+        balance: 100,
+        unstakedBalance: 10,
+        delegate: { address: delegateAddress },
+      })
+      mockedGetUnstakeRequests.mockRejectedValue(new Error('endpoint failure'))
+      mockedGetTokensBalances.mockResolvedValue([])
 
       const result = await getBalance(context, address)
 

package/src/logic/validateIntent.test.ts

@@ -1182,6 +1182,287 @@ describe('validateIntent', () => {
       expect(result.amount).toBe(0n)
       expect(result.totalSpent).toBe(1000n)
     })
+
+    it('fixed-amount TKEY (18 dec): no error when user has enough token and XTZ for fees [LIVE-35976]', async () => {
+      // 0.01 TKEY = 10^16 base units — vastly exceeds any XTZ balance in mutez, was the exact failure case
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tkeyAmount = 10n ** 16n
+
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TKEY', decimals: '18' },
+          },
+          balance: tkeyAmount.toString(),
+          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: tkeyAmount,
+      })
+
+      expect(result.errors.amount).toBeUndefined()
+      expect(result.amount).toBe(tkeyAmount)
+      expect(result.totalSpent).toBe(1000n) // only XTZ fees; token amount not included
+    })
+
+    it('fixed-amount token send: NotEnoughBalance when XTZ is insufficient for fees [LIVE-35976]', async () => {
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tkeyAmount = 10n ** 16n
+
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ balance: 500 })) // 500 mutez < 1000 fees
+      // Token balance is sufficient — this test must isolate the XTZ coverage branch only.
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TKEY', decimals: '18' },
+          },
+          balance: tkeyAmount.toString(),
+          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: tkeyAmount,
+      })
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
+
+    it('fixed-amount token send: NotEnoughBalance when token balance is insufficient [LIVE-35976]', async () => {
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tkeyAmount = 10n ** 16n
+
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TKEY', decimals: '18' },
+          },
+          balance: (tkeyAmount - 1n).toString(), // one unit short
+          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: tkeyAmount,
+      })
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
+
+    it('fixed-amount USDt (6 dec): passes correctly, not just accidentally, after fix [LIVE-35976]', async () => {
+      // 0.01 USDt = 10_000 base units — previously passed only because 10_000 < XTZ balance by coincidence
+      const contract = 'KT1XnTn74bagnxYoFErbDH5QRAULUDtpXkmV'
+      const usdtAmount = 10_000n
+
+      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: usdtAmount.toString(),
+          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: usdtAmount,
+      })
+
+      expect(result.errors.amount).toBeUndefined()
+      expect(result.totalSpent).toBe(1000n) // only fees in XTZ
+    })
+
+    it('unrevealed account + fixed-amount FA2 token send: no error and totalSpent equals reveal fees only [LIVE-35976]', async () => {
+      // Unrevealed accounts skip taquito estimation and get a fixed 2000n fee.
+      // Before the fix, calculateAmounts fell through to `amount + estimatedFees`, mixing token
+      // base units with mutez. After the fix it correctly returns `totalSpent: estimatedFees`.
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tkeyAmount = 10n ** 16n
+
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ revealed: false }))
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TKEY', decimals: '18' },
+          },
+          balance: tkeyAmount.toString(),
+          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: tkeyAmount,
+      })
+
+      expect(mockEstimateFees).not.toHaveBeenCalled()
+      expect(result.errors.amount).toBeUndefined()
+      expect(result.amount).toBe(tkeyAmount)
+      expect(result.totalSpent).toBe(2000n) // only XTZ reveal+tx fees; no token units mixed in
+    })
+
+    it('unrevealed account + fixed-amount FA2 token send: NotEnoughBalance when token balance is insufficient [LIVE-35976]', async () => {
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tkeyAmount = 10n ** 16n
+
+      mockGetAccountByAddress.mockResolvedValue(makeUserAccount({ revealed: false }))
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TKEY', decimals: '18' },
+          },
+          balance: (tkeyAmount - 1n).toString(), // one unit short
+          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: tkeyAmount,
+      })
+
+      expect(mockEstimateFees).not.toHaveBeenCalled()
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance)
+    })
+
+    it('send-max token: amount stays in token units when taquito reports balance_too_low', async () => {
+      // Regression guard for the optimization that skips fetchTokenBalance when errors.amount is set.
+      // For send-max, tokenBalance is also used as the returned amount — skipping it would cause
+      // calculateAmounts to fall back to the native XTZ path and return mutez instead of token units.
+      const contract = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
+      const tokenBalance = 5_000_000n
+
+      mockEstimateFees.mockResolvedValue({
+        fees: 0n,
+        gasLimit: 0n,
+        storageLimit: 0n,
+        estimatedFees: 0n,
+        taquitoError: 'proto.024-PtTALLiN.contract.balance_too_low',
+      })
+      mockGetTokensBalances.mockResolvedValue([
+        {
+          id: 1,
+          account: { address: senderAddress },
+          token: {
+            id: 1,
+            contract: { address: contract },
+            tokenId: '0',
+            standard: 'fa2' as const,
+            metadata: { symbol: 'TK', decimals: '6' },
+          },
+          balance: tokenBalance.toString(),
+          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).toBeInstanceOf(NotEnoughBalance)
+      expect(mockGetTokensBalances).toHaveBeenCalled()
+      expect(result.amount).toBe(tokenBalance)
+    })
   })
 
   describe('native XTZ send max', () => {

package/src/logic/validateIntent.ts

@@ -238,6 +238,12 @@ function calculateAmounts(
     return calculateNativeSendMaxAmountForUser(spendable, estimatedFees, estimatedAmount)
   }
 
+  // FA1.2/FA2 fixed-amount send: `intent.amount` is in token base units; fees are in XTZ mutez.
+  // Never add the token amount to the native coverage check — the units are incompatible.
+  if (intent.type === 'send' && parseTezosTokenAsset(intent.asset) !== null) {
+    return { amount: intent.amount, totalSpent: estimatedFees }
+  }
+
   const amount = intent.amount
   return { amount, totalSpent: amount + estimatedFees }
 }
@@ -307,11 +313,11 @@ async function estimateFeesForIntent(
   }
 }
 
-async function fetchTokenBalanceForSendMax(
+async function fetchTokenBalance(
   config: TezosCoinConfig,
   intent: TransactionIntent
 ): Promise<bigint | undefined> {
-  if (intent.type !== 'send' || !intent.useAllAmount) {
+  if (intent.type !== 'send') {
     return undefined
   }
 
@@ -383,7 +389,25 @@ export async function validateIntent(
     estimatedAmount = feeResult.estimatedAmount
     Object.assign(errors, feeResult.errors)
 
-    const tokenBalanceForSendMax = await fetchTokenBalanceForSendMax(config, intent)
+    // Skip the TzKT call only for fixed-amount sends where errors.amount is already set — the token
+    // balance would only be used for coverage, which is also gated on !errors.amount.
+    // For send-max we always fetch: calculateAmounts uses tokenBalanceForSendMax as the sent amount,
+    // so skipping would cause it to fall back to the native XTZ path and return a wrong unit.
+    // The TzKT call is isolated in its own try-catch so that a network failure here does not reach
+    // 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
+    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
+      }
+    }
+    // send-max uses the full token balance as the sent amount; fixed-amount only needs it for coverage
+    const tokenBalanceForSendMax = intent.useAllAmount ? tokenBalance : undefined
 
     const amounts = calculateAmounts(
       intent,
@@ -406,6 +430,19 @@ 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.)
+    if (
+      !errors.amount &&
+      intent.type === 'send' &&
+      !intent.useAllAmount &&
+      tokenBalance !== undefined
+    ) {
+      if (amount > tokenBalance) {
+        errors.amount = new NotEnoughBalance()
+      }
+    }
   } catch (e) {
     errors.estimation = e as Error
     estimatedFees = 0n