@ledgerhq/coin-tezos 10.2.2 → 10.2.6

package/src/api/index.test.ts

@@ -8,6 +8,8 @@ import {
   createSendTransactionIntentMockData,
   createStakingTransactionIntentMockData,
 } from '@ledgerhq/coin-module-framework/test-utils'
+import { getRevealFee } from '@taquito/taquito'
+import { MAPPED_TAQUITO_ERRORS } from '../utils'
 import { createApi } from './index'
 
 // The tzkt factory `createTzktApi(config)` builds a fresh object on every call, so a spy on a
@@ -298,6 +300,69 @@ describe('craftTransaction', () => {
       )
     })
 
+    it('splits the reported total so the crafted batch fees sum back to it', async () => {
+      // 300 no longer clamps both former reveal-fee sources to the same floor: the estimation
+      // reported Taquito's static constant while the reveal carried the node's live suggestion.
+      const minFees = 300
+      const unrevealedSender = 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr'
+      const txFee = 2000n
+      const staticRevealFee = BigInt(getRevealFee(unrevealedSender))
+      const reportedTotal = txFee + staticRevealFee
+
+      const contextLowMinFees = makeContext({
+        status: { type: 'active' },
+        baker: { url: 'https://baker.example.com' },
+        explorer: { url: 'foo', maxTxQuery: 1 },
+        node: { url: 'bar' },
+        fees: {
+          minGasLimit: 600,
+          minRevealGasLimit: 300,
+          minStorageLimit: 0,
+          minFees,
+          minEstimatedFees: minFees,
+        },
+      })
+
+      const unrevealedAccount: APIAccount = {
+        type: 'user',
+        balance: 1000000,
+        revealed: false,
+        address: unrevealedSender,
+        publicKey: 'edpktest',
+        counter: 0,
+        delegationLevel: 0,
+        delegationTime: '2021-01-01T00:00:00Z',
+        numTransactions: 0,
+        firstActivityTime: '2021-01-01T00:00:00Z',
+      }
+      mockGetAccountByAddress
+        .mockResolvedValueOnce(unrevealedAccount)
+        .mockResolvedValueOnce(unrevealedAccount)
+
+      logicEstimateFees.mockResolvedValue({
+        estimatedFees: reportedTotal,
+        fees: txFee,
+        gasLimit: 10000n,
+        storageLimit: 0n,
+        parameters: { gasLimit: 10000n, storageLimit: 0n, txFee },
+      })
+
+      await api.craftTransaction(
+        contextLowMinFees,
+        createSendTransactionIntentMockData({
+          type: 'send',
+          sender: unrevealedSender,
+          senderPublicKey: '00d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a',
+          recipient: 'tz1recipient',
+          amount: 1000n,
+        })
+      )
+
+      const craftedFee = logicCraftTransactionMock.mock.calls[0][2].fee
+      expect(BigInt(craftedFee.fees) + BigInt(craftedFee.revealFees)).toBe(reportedTotal)
+      expect(craftedFee.revealFees).toBe(staticRevealFee.toString())
+    })
+
     it('craft transaction with customFee splits total for unrevealed delegate so total equals customFee', async () => {
       const minFees = 1000
       const unrevealedSender = 'tz2TaTpo31sAiX2HBJUTLLdUnqVJR4QjLy1V'
@@ -584,6 +649,118 @@ describe('estimateFees', () => {
     expect(result.parameters?.storageLimit).toBe(DEFAULT_STORAGE_LIMIT)
   })
 
+  it('does not retry keyless for a token estimate after an unrelated failure', async () => {
+    // A keyless retry here would surface as PublicKeyNotFoundError and hide the real error.
+    const nodeError = Object.assign(new Error('Http error response: (500)'), {
+      status: 500,
+      body: '[{"kind":"permanent","id":"proto.025-PsUshuai.gas_limit_too_high"}]',
+    })
+    logicEstimateFees.mockRejectedValue(nodeError)
+
+    await expect(
+      api.estimateFees(context, {
+        intentType: 'transaction',
+        type: 'send',
+        sender: 'tz1test',
+        recipient: 'tz1recipient',
+        amount: 1000n,
+        asset: { type: 'token', assetReference: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU:0' },
+      })
+    ).rejects.toThrow('Http error response: (500)')
+
+    expect(logicEstimateFees).toHaveBeenCalledTimes(1)
+    logicEstimateFees.mockReset()
+  })
+
+  it('still retries keyless for a native estimate after an unrelated failure', async () => {
+    // Native estimation has no gas cap yet, so it hits the same block-gas overflow and depends
+    // on the keyless retry to reach the fallback. Without it an ordinary send reports no fees.
+    const blockOverflow = Object.assign(new Error('Http error response: (500)'), {
+      status: 500,
+      body: '[{"kind":"temporary","id":"proto.025-PsUshuai.gas_exhausted.block"}]',
+    })
+    logicEstimateFees
+      .mockRejectedValueOnce(blockOverflow)
+      .mockRejectedValueOnce(new Error('Public key not found'))
+
+    const unrevealedSender = 'tz1unrevealed'
+    const unrevealedAccount: APIAccount = {
+      type: 'user',
+      balance: 1000000,
+      revealed: false,
+      address: unrevealedSender,
+      publicKey: undefined,
+      counter: 0,
+      delegationLevel: 0,
+      delegationTime: '2021-01-01T00:00:00Z',
+      numTransactions: 0,
+      firstActivityTime: '2021-01-01T00:00:00Z',
+    }
+    mockGetAccountByAddress.mockResolvedValue(unrevealedAccount)
+    mockGetTezosToolkit.mockReturnValueOnce({
+      estimate: { transfer: jest.fn().mockRejectedValue(new Error('Public key not found')) },
+    })
+
+    const result = await api.estimateFees(
+      context,
+      createSendTransactionIntentMockData({
+        type: 'send',
+        sender: unrevealedSender,
+        recipient: 'tz1recipient',
+        amount: 1000n,
+      })
+    )
+
+    expect(logicEstimateFees).toHaveBeenCalledTimes(2)
+    expect(result.parameters?.gasLimit).toBe(2500n)
+    logicEstimateFees.mockReset()
+  })
+
+  it('retries keyless for contract.manager.inconsistent_hash', async () => {
+    const inconsistentHash = Object.assign(new Error('Http error response: (500)'), {
+      status: 500,
+      body: '[{"kind":"permanent","id":"proto.025-PsUshuai.contract.manager.inconsistent_hash"}]',
+    })
+    logicEstimateFees.mockRejectedValueOnce(inconsistentHash).mockResolvedValueOnce({
+      estimatedFees: DEFAULT_ESTIMATED_FEES,
+      gasLimit: DEFAULT_GAS_LIMIT,
+      storageLimit: DEFAULT_STORAGE_LIMIT,
+    })
+
+    const result = await api.estimateFees(
+      context,
+      createSendTransactionIntentMockData({
+        type: 'send',
+        sender: 'tz1test',
+        recipient: 'tz1recipient',
+        amount: 1000n,
+        asset: { type: 'token', assetReference: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU:0' },
+      })
+    )
+
+    expect(logicEstimateFees).toHaveBeenCalledTimes(2)
+    expect(result.parameters?.gasLimit).toBe(DEFAULT_GAS_LIMIT)
+    logicEstimateFees.mockReset()
+  })
+
+  it('does not answer a token estimate with native fallback constants', async () => {
+    // Native fallback limits under-provision an FA2 transfer, which then fails on chain.
+    logicEstimateFees.mockRejectedValue(new Error('Public key not found'))
+
+    await expect(
+      api.estimateFees(context, {
+        intentType: 'transaction',
+        type: 'send',
+        sender: 'tz1test',
+        recipient: 'tz1recipient',
+        amount: 1000n,
+        asset: { type: 'token', assetReference: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU:0' },
+      })
+    ).rejects.toThrow('Public key not found')
+
+    logicEstimateFees.mockReset()
+  })
+
   it('should not throw for delegate.unchanged errors', async () => {
     logicEstimateFees.mockResolvedValue({
       estimatedFees: DEFAULT_ESTIMATED_FEES,
@@ -641,6 +818,37 @@ describe('estimateFees', () => {
     })
   })
 
+  it.each(MAPPED_TAQUITO_ERRORS)(
+    'should not throw for %s, which validateIntent maps',
+    async (id) => {
+      logicEstimateFees.mockResolvedValue({
+        estimatedFees: DEFAULT_ESTIMATED_FEES,
+        gasLimit: DEFAULT_GAS_LIMIT,
+        storageLimit: DEFAULT_STORAGE_LIMIT,
+        taquitoError: `proto.025-PsUshuai.${id}`,
+      })
+      const result = await api.estimateFees(
+        context,
+        createStakingTransactionIntentMockData({
+          type: 'stake',
+          mode: 'delegate',
+          sender: 'tz1test',
+          recipient: 'tz1validator',
+          amount: 1n,
+          valAddress: 'tz1validator',
+        })
+      )
+
+      expect(result).toEqual({
+        value: DEFAULT_ESTIMATED_FEES,
+        parameters: {
+          gasLimit: DEFAULT_GAS_LIMIT,
+          storageLimit: DEFAULT_STORAGE_LIMIT,
+        },
+      })
+    }
+  )
+
   it('returns total estimation for unrevealed delegate when minFees applied (composite)', async () => {
     const unrevealedSender = 'tz2TaTpo31sAiX2HBJUTLLdUnqVJR4QjLy1V'
     mockGetAccountByAddress.mockResolvedValueOnce({

package/src/api/index.ts

@@ -20,8 +20,6 @@ import type {
 import { rejectBalanceOptions } from '@ledgerhq/coin-module-framework/api/getBalance/rejectBalanceOptions'
 import { IncorrectTypeError } from '@ledgerhq/coin-module-framework/api/index'
 import { craftTransactionData } from '@ledgerhq/coin-module-framework/logic/craftTransactionData'
-import { log } from '@ledgerhq/logs'
-import { getRevealFee } from '@taquito/taquito'
 import { getPkhfromPk, validatePublicKey, ValidationResult } from '@taquito/utils'
 import {
   broadcast,
@@ -38,6 +36,7 @@ import {
   rawEncode,
   validateIntent,
 } from '../logic'
+import { getRevealFeeForEstimation } from '../logic/estimateFees'
 import { getTezosToolkit } from '../logic/tezosToolkit'
 import { validateAddress } from '../logic/validateAddress'
 import { hasManagerKey } from '../network/types'
@@ -45,6 +44,7 @@ import { createTzktApi } from '../network/tzkt'
 import {
   DUST_MARGIN_MUTEZ,
   hasEmptyBalance,
+  isMappedTaquitoError,
   normalizePublicKeyForAddress,
   parseTezosTokenAsset,
   resolveTezosOperationMode,
@@ -107,6 +107,27 @@ function isTezosTransactionType(
 ): type is 'send' | 'delegate' | 'undelegate' | 'stake' | 'unstake' | 'finalize_unstake' {
   return ['send', 'delegate', 'undelegate', 'stake', 'unstake', 'finalize_unstake'].includes(type)
 }
+/**
+ * Whether a failed estimation is the `contract.manager.inconsistent_hash` case that the
+ * keyless retry exists for. Taquito surfaces it as an HTTP error whose body carries the
+ * protocol error id.
+ */
+function isInconsistentHashError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) {
+    return false
+  }
+  const parts: unknown[] = []
+  if ('message' in error) {
+    parts.push(error.message)
+  }
+  if ('body' in error) {
+    parts.push(error.body)
+  }
+  return parts.some(
+    (part) => typeof part === 'string' && part.includes('contract.manager.inconsistent_hash')
+  )
+}
+
 async function craft(
   context: TezosContext,
   transactionIntent: TransactionIntent,
@@ -160,25 +181,24 @@ async function craft(
   const needsReveal = hasManagerKey(senderApiAcc) && !senderApiAcc.revealed
   const totalFee = Number(fee.fees || '0')
 
-  const feesConfig = config.fees
   const revealFeeForSplit = needsReveal
-    ? Math.max(feesConfig.minFees ?? 0, getRevealFee(transactionIntent.sender))
+    ? getRevealFeeForEstimation(config, transactionIntent.sender)
     : 0
 
-  let txFee: number
-  if (customFees) {
-    txFee = needsReveal ? Math.max(totalFee - revealFeeForSplit, 0) : totalFee
-  } else if (estimation.parameters?.txFee !== undefined) {
-    txFee = Number(estimation.parameters.txFee)
-  } else {
-    txFee = needsReveal ? Math.max(totalFee - revealFeeForSplit, 0) : totalFee
-  }
+  // The device compares the sum of the batch fees against the single total it was handed, so the
+  // split has to close exactly.
+  const desiredTxFee =
+    !customFees && estimation.parameters?.txFee !== undefined
+      ? Number(estimation.parameters.txFee)
+      : totalFee - revealFeeForSplit
+  const txFee = Math.min(Math.max(desiredTxFee, 0), totalFee)
+  const revealFee = totalFee - txFee
 
   const txForCraft = {
     type: mappedType,
     recipient: transactionIntent.recipient,
     amount: amountToUse,
-    fee: { ...fee, fees: txFee.toString() },
+    fee: { ...fee, fees: txFee.toString(), revealFees: revealFee.toString() },
     ...(tokenCraftInfo && {
       contractAddress: tokenCraftInfo.contractAddress,
       tokenId: tokenCraftInfo.tokenId,
@@ -304,21 +324,20 @@ async function estimate(
       // it's not clear why this happens, it couldn't be further investigated
       // so we fallback to make an estimation without the public key
       // there is a test that covers this, see "fallback to an estimation without the public key" index-mainnet.integ.test.ts
-      log('estimate-error', 'error estimating fees, trying without pubkey', { error })
+      //
+      // A token estimate retries only for that error. Otherwise the keyless retry throws
+      // PublicKeyNotFoundError, and the native-transfer fallback answering it under-provisions
+      // the FA2 transfer. Other modes still depend on reaching that fallback.
+      if (tezosModeForEstimate === 'send_token' && !isInconsistentHashError(error)) {
+        throw error
+      }
+      context.logger('estimate-error', 'error estimating fees, trying without pubkey', { error })
       estimation = await logicEstimate()
     }
 
-    if (
-      estimation.taquitoError &&
-      !estimation.taquitoError.includes('delegate.unchanged') &&
-      !estimation.taquitoError.includes('subtraction_underflow') &&
-      !estimation.taquitoError.includes('balance_too_low') &&
-      !estimation.taquitoError.includes('script_rejected') &&
-      !estimation.taquitoError.includes(
-        'cannot_stake_with_unfinalizable_unstake_requests_to_another_delegate'
-      )
-    ) {
-      throw new Error(`Fees estimation failed: ${estimation.taquitoError}`)
+    const { taquitoError } = estimation
+    if (taquitoError && !isMappedTaquitoError(taquitoError)) {
+      throw new Error(`Fees estimation failed: ${taquitoError}`)
     }
 
     return {
@@ -333,6 +352,14 @@ async function estimate(
   } catch (error: unknown) {
     // Handle PublicKeyNotFoundError
     if (error instanceof Error && error.message.includes('Public key not found')) {
+      // Everything below describes a native tez transfer. An FA2 transfer costs several times
+      // more gas and the amounts vary per contract, so these values silently under-provision
+      // it: the operation is crafted correctly and the chain rejects it with gas_exhausted,
+      // charging the fee.
+      if (tezosModeForEstimate === 'send_token') {
+        throw error
+      }
+
       const apiAccount = await api.getAccountByAddress(transactionIntent.recipient)
       const storageLimit =
         !hasEmptyBalance(apiAccount) || transactionIntent.type === 'stake' ? 0n : 277n
@@ -358,11 +385,11 @@ async function estimate(
       } catch {
         // When estimation fails because the sender is unrevealed (PublicKeyNotFoundError),
         // fallback to a conservative gas value suitable for typical new-account XTZ transfers.
-        // This buffer (~2500 gas) is more than enough for a standard transfer that actually uses ~1420 gas.
+        // A standard transfer consumes about 2169 gas, so 2500 leaves a small margin.
         // The fee is computed according to Taquito's calculation so it will satisfy the Tezos prefilter rule:
         //   total_fees >= ceil(100 + 0.1*total_gas + op_size)
         // We use a base of 120 instead of 100 to mimic Taquito and minimize rejected low-fee ops.
-        const SAFE_FALLBACK_GAS = 2500 // covers typical new-account transfer (~1420) with buffer
+        const SAFE_FALLBACK_GAS = 2500
         const FALLBACK_OP_SIZE_BYTES = 154 // typical forged size for a simple XTZ transfer
         txGasLimit = BigInt(SAFE_FALLBACK_GAS)
         baseTxFee = BigInt(
@@ -374,7 +401,7 @@ async function estimate(
       }
 
       const revealFee = needsReveal
-        ? BigInt(Math.max(config.fees.minFees ?? 0, getRevealFee(transactionIntent.sender)))
+        ? BigInt(getRevealFeeForEstimation(config, transactionIntent.sender))
         : 0n
       const totalFee = baseTxFee + revealFee
 

package/src/logic/craftRawOperations.ts

@@ -98,7 +98,7 @@ export async function craftRawOperations(
     if (getPkhfromPk(normalizedPk) !== sender) {
       throw new Error('craftRawOperations: public key does not match the sender address')
     }
-    const reveal = await estimateRevealLimits(tezosToolkit, sender, feesConfig)
+    const reveal = await estimateRevealLimits(context, tezosToolkit, sender)
     contents.push({
       kind: OpKind.REVEAL,
       source: sender,
@@ -232,9 +232,8 @@ async function estimateOperations(
       `craftRawOperations: expected ${expected} estimate(s) for ${operations.length} operation(s), got ${estimates.length}`
     )
   }
-  // Keep the trailing N estimates, dropping a prepended reveal estimate if present. The
-  // REVEAL op itself uses estimateRevealLimits (config-clamped, consistent with
-  // craftTransaction) rather than this batch-prepended value, which is discarded.
+  // Keep the trailing N estimates, dropping a prepended reveal estimate if present. The REVEAL
+  // op itself uses the config-clamped estimateRevealLimits value, not this one.
   return estimates.slice(estimates.length - operations.length)
 }
 

package/src/logic/craftTransaction.test.ts

@@ -177,6 +177,36 @@ describe('craftTransaction', () => {
     ])
   })
 
+  it('stamps the reveal fee the caller supplies, not the node estimate', async () => {
+    // The device asserts that the batch fees sum to the single total the caller reported, which a
+    // reveal priced from the node would break.
+    mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
+    mockTezosToolkit.estimate.reveal.mockResolvedValue({
+      gasLimit: 271,
+      storageLimit: 0,
+      suggestedFeeMutez: 310,
+    })
+    currentConfig = {
+      ...mockConfig,
+      fees: { ...mockConfig.fees, minFees: 0, minRevealGasLimit: 0 },
+    }
+
+    const account = { address: 'tz1...' }
+    const transaction: TransactionInput = {
+      type: 'send',
+      recipient: 'tz2...',
+      amount: BigInt(1000),
+      fee: { fees: '100', gasLimit: '200', storageLimit: '300', revealFees: '334' },
+    }
+    const publicKey = { publicKey: 'publicKey', publicKeyHash: 'publicKeyHash' }
+
+    const result = await craftTransaction(context, account, transaction, publicKey)
+
+    expect(result.contents[0]).toEqual(
+      expect.objectContaining({ kind: OpKind.REVEAL, fee: '334', gas_limit: '271' })
+    )
+  })
+
   describe('when suggested fee is above or below minFees floor', () => {
     it('craft transaction when default estimation is greater than minFees', async () => {
       mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })

package/src/logic/craftTransaction.ts

@@ -13,6 +13,12 @@ export type TransactionFee = {
   fees?: string
   gasLimit?: string
   storageLimit?: string
+  /**
+   * Fee to stamp on the leading reveal operation. The caller sets it so the batch fees sum to the
+   * total it already reported. Without it the reveal keeps its own node estimate, which that
+   * total never accounted for.
+   */
+  revealFees?: string
 }
 export type TransactionType =
   | 'OUT'
@@ -72,12 +78,11 @@ export async function craftTransaction(
   const contents: OperationContents[] = []
 
   if (publicKey !== undefined) {
-    const feesConfig = config.fees
-    const reveal = await estimateRevealLimits(tezosToolkit, address, feesConfig)
+    const reveal = await estimateRevealLimits(context, tezosToolkit, address)
 
     contents.push({
       kind: OpKind.REVEAL,
-      fee: reveal.fee.toString(),
+      fee: transaction.fee.revealFees ?? reveal.fee.toString(),
       gas_limit: reveal.gasLimit.toString(),
       storage_limit: reveal.storageLimit.toString(),
       source: publicKey.publicKeyHash,