@ledgerhq/coin-tezos 6.6.0-nightly.3 → 6.7.0-nightly.0

package/src/api/index.test.ts

@@ -2,7 +2,7 @@ import type { Operation } from "@ledgerhq/coin-framework/api/types";
 import type { APIAccount } from "../network/types";
 import networkApi from "../network/tzkt";
 import { createApi } from "./index";
-import type { TezosTransactionIntent } from "./types";
+import { TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 
 const DEFAULT_ESTIMATED_FEES = 300n;
 const DEFAULT_GAS_LIMIT = 30n;
@@ -107,11 +107,12 @@ describe("Testing craftTransaction function", () => {
       storageLimit: DEFAULT_STORAGE_LIMIT,
     });
     await api.craftTransaction({
+      intentType: "transaction",
       type: "send",
       sender: "tz1test",
       recipient: "tz1recipient",
       amount: 1000n,
-    } as TezosTransactionIntent);
+    } as TransactionIntent);
     expect(logicEstimateFees).toHaveBeenCalledTimes(1);
     expect(logicCraftTransactionMock).toHaveBeenCalledWith(
       expect.objectContaining({ address: "tz1test" }),
@@ -139,11 +140,12 @@ describe("Testing craftTransaction function", () => {
       });
       await api.craftTransaction(
         {
+          intentType: "transaction",
           type: "send",
           sender: "tz1test",
           recipient: "tz1recipient",
           amount: 1000n,
-        } as TezosTransactionIntent,
+        } as TransactionIntent,
         {
           value: customFees,
         },
@@ -173,11 +175,12 @@ describe("Testing estimateFees function", () => {
       storageLimit: DEFAULT_STORAGE_LIMIT,
     });
     const result = await api.estimateFees({
+      intentType: "transaction",
       type: "send",
       sender: "tz1test",
       recipient: "tz1recipient",
       amount: 1000n,
-    } as TezosTransactionIntent);
+    } as TransactionIntent);
     expect(result).toEqual({
       value: DEFAULT_ESTIMATED_FEES,
       parameters: {
@@ -196,11 +199,12 @@ describe("Testing estimateFees function", () => {
     });
     await expect(
       api.estimateFees({
+        intentType: "transaction",
         type: "send",
         sender: "tz1test",
         recipient: "tz1recipient",
         amount: 1000n,
-      } as TezosTransactionIntent),
+      } as TransactionIntent),
     ).rejects.toThrow("Fees estimation failed: test");
   });
 
@@ -212,11 +216,12 @@ describe("Testing estimateFees function", () => {
       taquitoError: "proto.022-PsRiotum.delegate.unchanged",
     });
     const result = await api.estimateFees({
+      intentType: "staking",
       type: "delegate",
       sender: "tz1test",
       recipient: "tz1validator",
       amount: 0n,
-    } as TezosTransactionIntent);
+    } as TransactionIntent);
 
     expect(result).toEqual({
       value: DEFAULT_ESTIMATED_FEES,

package/src/api/index.ts

@@ -24,6 +24,7 @@ import {
   validateIntent,
   getStakes,
 } from "../logic";
+import { getTezosToolkit } from "../logic/tezosToolkit";
 import api from "../network/tzkt";
 import type { TezosApi, TezosFeeEstimation } from "./types";
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
@@ -32,6 +33,7 @@ import { validatePublicKey, ValidationResult, getPkhfromPk } from "@taquito/util
 import { getRevealFee } from "@taquito/taquito";
 import {
   DUST_MARGIN_MUTEZ,
+  hasEmptyBalance,
   mapIntentTypeToTezosMode,
   normalizePublicKeyForAddress,
 } from "../utils";
@@ -43,6 +45,14 @@ export function createApi(config: TezosConfig): TezosApi {
     broadcast,
     combine,
     craftTransaction: craft,
+    craftRawTransaction: (
+      _transaction: string,
+      _sender: string,
+      _publicKey: string,
+      _sequence: number,
+    ): Promise<CraftedTransaction> => {
+      throw new Error("craftRawTransaction is not supported");
+    },
     estimateFees: estimate,
     getBalance: balance,
     lastBlock,
@@ -151,11 +161,14 @@ async function craft(
 
   let txFee: number;
   if (customFees) {
-    txFee = totalFee;
+    txFee = needsReveal ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0) : totalFee;
   } else if (estimation.parameters?.txFee !== undefined) {
     txFee = Number(estimation.parameters.txFee);
   } else {
-    txFee = needsReveal ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0) : totalFee;
+    const calculatedTxFee = needsReveal
+      ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0)
+      : totalFee;
+    txFee = calculatedTxFee;
   }
 
   const txForCraft = {
@@ -198,6 +211,7 @@ async function craft(
 
 async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeEstimation> {
   // avoid taquito error when estimating a 0-amount transfer during input
+  const config = coinConfig.getCoinConfig();
   if (
     transactionIntent.type === "send" &&
     transactionIntent.amount === 0n &&
@@ -267,13 +281,43 @@ async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeE
   } catch (error: any) {
     // Handle PublicKeyNotFoundError
     if (error?.message?.includes("Public key not found")) {
+      const apiAccount = await api.getAccountByAddress(transactionIntent.recipient);
+      const storageLimit =
+        !hasEmptyBalance(apiAccount) || transactionIntent.type === "stake" ? 0n : 277n;
+
+      // Check if account needs reveal for proper fee calculation
+      const senderApiAcc = await api.getAccountByAddress(transactionIntent.sender);
+      const needsReveal = senderApiAcc.type === "user" && !senderApiAcc.revealed;
+
+      // Production-calibrated fallback fee when Taquito estimation fails (~388 mutez observed)
+      const DEFAULT_TX_FEE_FALLBACK = 388;
+      let baseTxFee: bigint;
+
+      try {
+        const toolkit = getTezosToolkit();
+        const simpleEstimate = await toolkit.estimate.transfer({
+          to: transactionIntent.recipient,
+          amount: Number(transactionIntent.amount),
+          mutez: true,
+          source: transactionIntent.sender,
+        });
+        // Use Taquito estimation, respecting minFees from config
+        baseTxFee = BigInt(Math.max(config.fees.minFees, simpleEstimate.suggestedFeeMutez));
+      } catch {
+        // Fallback to production-calibrated default if estimation fails
+        baseTxFee = BigInt(Math.max(DEFAULT_TX_FEE_FALLBACK, config.fees.minFees));
+      }
+
+      const revealFee = needsReveal ? BigInt(getRevealFee(transactionIntent.sender)) : 0n;
+      const totalFee = baseTxFee + revealFee;
+
       return {
-        value: 1000n, // Safe default with reveal fees (500 + 374 reveal + buffer)
+        value: totalFee,
         parameters: {
           gasLimit: 10000n,
-          storageLimit: 300n,
+          storageLimit,
           amount: 0n,
-          txFee: 1000n,
+          txFee: baseTxFee,
         },
       };
     } else {

package/src/api/types.ts

@@ -1,4 +1,4 @@
-import type { Api, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { Api, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 
 export type TezosFeeParameters = {
   gasLimit: bigint;
@@ -11,6 +11,5 @@ export type TezosFeeEstimation = FeeEstimation & {
 };
 
 export type TezosSender = { address: string; xpub?: string };
-export type TezosTransactionIntent = TransactionIntent;
 
 export type TezosApi = Api;

package/src/logic/validateIntent.test.ts

@@ -58,6 +58,7 @@ describe("validateIntent", () => {
   describe("recipient validation", () => {
     it("should return RecipientRequired error when recipient is missing", async () => {
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -70,6 +71,7 @@ describe("validateIntent", () => {
 
     it("should return InvalidAddress error for invalid recipient", async () => {
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -82,6 +84,7 @@ describe("validateIntent", () => {
 
     it("should return InvalidAddressBecauseDestinationIsAlsoSource when sender equals recipient", async () => {
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -96,6 +99,7 @@ describe("validateIntent", () => {
   describe("amount validation", () => {
     it("should return AmountRequired error when amount is zero and not useAllAmount", async () => {
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -109,6 +113,7 @@ describe("validateIntent", () => {
 
     it("should not return AmountRequired error when useAllAmount is true", async () => {
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -140,6 +145,7 @@ describe("validateIntent", () => {
       });
 
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -168,6 +174,7 @@ describe("validateIntent", () => {
       });
 
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,
@@ -183,6 +190,7 @@ describe("validateIntent", () => {
   describe("transaction types", () => {
     it("should pass validation for delegate transaction", async () => {
       const result = await validateIntent({
+        intentType: "staking",
         asset: { type: "native" },
         type: "delegate",
         sender: senderAddress,
@@ -195,6 +203,7 @@ describe("validateIntent", () => {
 
     it("should pass validation for undelegate transaction", async () => {
       const result = await validateIntent({
+        intentType: "staking",
         asset: { type: "native" },
         type: "undelegate",
         sender: senderAddress,
@@ -207,6 +216,7 @@ describe("validateIntent", () => {
 
     it("should handle stake intent (mapped to delegate)", async () => {
       const result = await validateIntent({
+        intentType: "staking",
         asset: { type: "native" },
         type: "stake",
         sender: senderAddress,
@@ -219,6 +229,7 @@ describe("validateIntent", () => {
 
     it("should handle unstake intent (mapped to undelegate)", async () => {
       const result = await validateIntent({
+        intentType: "staking",
         asset: { type: "native" },
         type: "unstake",
         sender: senderAddress,
@@ -243,6 +254,7 @@ describe("validateIntent", () => {
       });
 
       const result = await validateIntent({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: senderAddress,

package/src/utils.ts

@@ -1,17 +1,8 @@
 import { validatePublicKey, ValidationResult, b58Encode, PrefixV2 } from "@taquito/utils";
 import { DerivationType } from "@taquito/ledger-signer";
 import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
-
-/**
- * Default limits and fees for Tezos operations
- */
-// Safe fallback values aligned with Taquito estimation defaults for a simple transfer
-// These are used when network estimation is unavailable (e.g., signer not configured)
-const DEFAULT_LIMITS = {
-  GAS: 2169n,
-  STORAGE: 277n,
-  BASE_FEE: 491n,
-};
+import type { APIAccount } from "./network/types";
+import coinConfig from "./config";
 
 /**
  * Dust margin in mutez to prevent transaction failures on send max operations
@@ -106,10 +97,15 @@ export function normalizePublicKeyForAddress(
  * Creates default fallback estimation values
  */
 export function createFallbackEstimation() {
+  const config = coinConfig.getCoinConfig();
   return {
-    fees: DEFAULT_LIMITS.BASE_FEE,
-    gasLimit: DEFAULT_LIMITS.GAS,
-    storageLimit: DEFAULT_LIMITS.STORAGE,
-    estimatedFees: DEFAULT_LIMITS.BASE_FEE,
+    fees: BigInt(config.fees.minEstimatedFees),
+    gasLimit: BigInt(config.fees.minGasLimit),
+    storageLimit: BigInt(config.fees.minStorageLimit),
+    estimatedFees: BigInt(config.fees.minEstimatedFees),
   };
 }
+
+export function hasEmptyBalance(account: APIAccount) {
+  return (account.type === "user" && account.balance === 0) || account.type === "empty";
+}