@ledgerhq/coin-tezos 6.5.0 → 6.6.0-nightly.0

package/src/api/index.ts

@@ -21,11 +21,20 @@ import {
   lastBlock,
   listOperations,
   rawEncode,
+  validateIntent,
+  getStakes,
 } from "../logic";
 import api from "../network/tzkt";
 import type { TezosApi, TezosFeeEstimation } from "./types";
-import { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
-import { TezosOperationMode } from "../types";
+import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { RecommendUndelegation } from "@ledgerhq/errors";
+import { validatePublicKey, ValidationResult, getPkhfromPk } from "@taquito/utils";
+import { getRevealFee } from "@taquito/taquito";
+import {
+  DUST_MARGIN_MUTEZ,
+  mapIntentTypeToTezosMode,
+  normalizePublicKeyForAddress,
+} from "../utils";
 
 export function createApi(config: TezosConfig): TezosApi {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
@@ -38,31 +47,54 @@ export function createApi(config: TezosConfig): TezosApi {
     getBalance: balance,
     lastBlock,
     listOperations: operations,
+    getStakes,
+    validateIntent,
+    // required by signer to compute next valid sequence/counter
+    getSequence: async (address: string) => {
+      const accountInfo = await api.getAccountByAddress(address);
+      return accountInfo.type === "user" ? accountInfo.counter + 1 : 0;
+    },
     getBlock(_height): Promise<Block> {
       throw new Error("getBlock is not supported");
     },
     getBlockInfo(_height: number): Promise<BlockInfo> {
       throw new Error("getBlockInfo is not supported");
     },
-    getStakes(_address: string, _cursor?: Cursor): Promise<Page<Stake>> {
-      throw new Error("getStakes is not supported");
-    },
     getRewards(_address: string, _cursor?: Cursor): Promise<Page<Reward>> {
       throw new Error("getRewards is not supported");
     },
   };
 }
 
-function isTezosTransactionType(type: string): type is "send" | "delegate" | "undelegate" {
-  return ["send", "delegate", "undelegate"].includes(type);
+function isTezosTransactionType(
+  type: string,
+): type is "send" | "delegate" | "undelegate" | "stake" | "unstake" {
+  return ["send", "delegate", "undelegate", "stake", "unstake"].includes(type);
 }
 
 async function balance(address: string): Promise<Balance[]> {
   const value = await getBalance(address);
+  const accountInfo = await api.getAccountByAddress(address);
+  // tzkt returns `type: "empty"` for untouched accounts; legacy logic returns -1 in that case
+  // the generic bridge expects non-negative balances
+  const normalized = value < 0n ? 0n : value;
+  // include stake information so ui can reflect delegation on account page
+  const stake: Stake | undefined =
+    accountInfo.type === "user" && accountInfo.delegate?.address
+      ? {
+          uid: address,
+          address,
+          delegate: accountInfo.delegate.address,
+          state: "active",
+          asset: { type: "native" },
+          amount: BigInt(accountInfo.balance ?? 0),
+        }
+      : undefined;
   return [
     {
-      value,
+      value: normalized,
       asset: { type: "native" },
+      stake,
     },
   ];
 }
@@ -75,64 +107,180 @@ async function craft(
     throw new IncorrectTypeError(transactionIntent.type);
   }
 
-  // note that an estimation is always necessary to get gasLimit and storageLimit, if even using custom fees
-  const fee = await estimate(transactionIntent).then(fees => ({
-    fees: (customFees?.value ?? fees.value).toString(),
-    gasLimit: fees.parameters?.gasLimit?.toString(),
-    storageLimit: fees.parameters?.storageLimit?.toString(),
-  }));
+  // Always estimate to get gasLimit/storageLimit
+  const estimation = await estimate(transactionIntent);
+  const fee = {
+    fees: (customFees?.value ?? estimation.value).toString(),
+    gasLimit: estimation.parameters?.gasLimit?.toString(),
+    storageLimit: estimation.parameters?.storageLimit?.toString(),
+  };
 
-  const { contents } = await craftTransaction(
-    { address: transactionIntent.sender },
-    {
-      type: transactionIntent.type,
-      recipient: transactionIntent.recipient,
-      amount: transactionIntent.amount,
-      fee,
-    },
-  );
+  // Map generic staking intents to tezos modes
+  const mappedType = mapIntentTypeToTezosMode(transactionIntent.type);
 
-  const tx = await rawEncode(contents);
+  // Guard: send max is incompatible with delegated accounts
+  let amountToUse = transactionIntent.amount;
+  if (mappedType === "send" && transactionIntent.useAllAmount) {
+    const senderInfo = await api.getAccountByAddress(transactionIntent.sender);
+    if (senderInfo.type === "user" && senderInfo.delegate?.address) {
+      throw new RecommendUndelegation();
+    }
+    if (senderInfo.type === "user") {
+      // Use the amount calculated by the estimation which includes proper buffers and adjustments
+      if (estimation.parameters?.amount !== undefined) {
+        amountToUse = estimation.parameters.amount;
+      } else {
+        // Fallback to the original calculation if estimation doesn't provide amount
+        const bal = BigInt(senderInfo.balance);
+        const feeBI = BigInt(fee.fees || "0");
+        const dustMargin = BigInt(DUST_MARGIN_MUTEZ);
+        const totalToDeduct = feeBI + dustMargin;
+        amountToUse = bal > totalToDeduct ? bal - totalToDeduct : 0n;
+      }
+    } else {
+      amountToUse = 0n;
+    }
+  }
+
+  const accountForCraft = {
+    address: transactionIntent.sender,
+  };
+  const senderApiAcc = await api.getAccountByAddress(transactionIntent.sender);
+  const needsReveal = senderApiAcc.type === "user" && !senderApiAcc.revealed;
+  const totalFee = Number(fee.fees || "0");
+
+  let txFee: number;
+  if (customFees) {
+    txFee = totalFee;
+  } else if (estimation.parameters?.txFee !== undefined) {
+    txFee = Number(estimation.parameters.txFee);
+  } else {
+    txFee = needsReveal ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0) : totalFee;
+  }
+
+  const txForCraft = {
+    type: mappedType,
+    recipient: transactionIntent.recipient,
+    amount: amountToUse,
+    fee: { ...fee, fees: txFee.toString() },
+  };
+  const publicKeyForCraft =
+    needsReveal && transactionIntent.senderPublicKey
+      ? (() => {
+          // Accept either base58 or hex from device, and map curve using sender address
+          let pk = transactionIntent.senderPublicKey;
+          if (validatePublicKey(pk) !== ValidationResult.VALID) {
+            pk = normalizePublicKeyForAddress(pk, transactionIntent.sender) || pk;
+          }
+          // Verify the public key matches the sender address to avoid inconsistent_hash
+          let isPublicKeyValid = false;
+          try {
+            const derived = getPkhfromPk(pk);
+            isPublicKeyValid = derived === transactionIntent.sender;
+          } catch {
+            // getPkhfromPk failed = will fallback to basic validation below
+            isPublicKeyValid = false;
+          }
 
+          if (!isPublicKeyValid) {
+            // If derivation failed/doesn't match, check if the key is atleast valid format
+            if (validatePublicKey(pk) !== ValidationResult.VALID) {
+              throw new Error("Unable to normalize sender public key");
+            }
+          }
+          return { publicKey: pk, publicKeyHash: transactionIntent.sender };
+        })()
+      : undefined;
+  const { contents } = await craftTransaction(accountForCraft, txForCraft, publicKeyForCraft);
+  const tx = await rawEncode(contents);
   return { transaction: tx };
 }
 
 async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeEstimation> {
+  // avoid taquito error when estimating a 0-amount transfer during input
+  if (
+    transactionIntent.type === "send" &&
+    transactionIntent.amount === 0n &&
+    !transactionIntent.useAllAmount
+  ) {
+    return {
+      value: BigInt(DUST_MARGIN_MUTEZ),
+      parameters: {
+        gasLimit: 10000n,
+        storageLimit: 300n,
+        amount: 0n,
+        txFee: BigInt(DUST_MARGIN_MUTEZ),
+      },
+    };
+  }
   const senderAccountInfo = await api.getAccountByAddress(transactionIntent.sender);
+  // If the sender is not a user account, return default estimation values
+  if (senderAccountInfo.type !== "user") {
+    return {
+      value: BigInt(DUST_MARGIN_MUTEZ),
+      parameters: {
+        gasLimit: 10000n,
+        storageLimit: 300n,
+        amount: 0n,
+        txFee: BigInt(DUST_MARGIN_MUTEZ),
+      },
+    };
+  }
 
-  const {
-    estimatedFees: value,
-    gasLimit,
-    storageLimit,
-    taquitoError,
-  } = await estimateFees({
-    account: {
-      address: transactionIntent.sender,
-      revealed: senderAccountInfo.type === "user" && senderAccountInfo.revealed,
-      balance: BigInt(senderAccountInfo.type === "user" ? senderAccountInfo.balance : 0),
-      // NOTE: previously we checked for .sender.xpub
-      xpub:
-        transactionIntent.senderPublicKey ??
-        (senderAccountInfo.type === "user" ? senderAccountInfo.publicKey : undefined),
-    },
-    transaction: {
-      mode: transactionIntent.type as TezosOperationMode,
-      recipient: transactionIntent.recipient,
-      amount: transactionIntent.amount,
-    },
-  });
+  try {
+    const estimation = await estimateFees({
+      account: {
+        address: transactionIntent.sender,
+        revealed: senderAccountInfo.revealed,
+        balance: BigInt(senderAccountInfo.balance),
+        // try intent public key first and fallback to tzkt public key
+        xpub: transactionIntent.senderPublicKey ?? senderAccountInfo.publicKey,
+      },
+      transaction: {
+        // reuse the same mapping as craft
+        mode: mapIntentTypeToTezosMode(transactionIntent.type),
+        recipient: transactionIntent.recipient,
+        amount: transactionIntent.amount,
+        // legacy estimator needs this flag to pre-estimate fees
+        useAllAmount: !!transactionIntent.useAllAmount,
+      },
+    });
 
-  if (taquitoError !== undefined) {
-    throw new Error(`Fees estimation failed: ${taquitoError}`);
-  }
+    if (
+      estimation.taquitoError &&
+      !estimation.taquitoError.includes("delegate.unchanged") &&
+      !estimation.taquitoError.includes("subtraction_underflow") &&
+      !estimation.taquitoError.includes("balance_too_low")
+    ) {
+      throw new Error(`Fees estimation failed: ${estimation.taquitoError}`);
+    }
 
-  return {
-    value,
-    parameters: {
-      gasLimit,
-      storageLimit,
-    },
-  };
+    return {
+      value: estimation.estimatedFees,
+      parameters: {
+        gasLimit: estimation.gasLimit,
+        storageLimit: estimation.storageLimit,
+        amount: estimation.amount,
+        txFee: estimation.fees,
+      },
+    };
+  } catch (error: any) {
+    // Handle PublicKeyNotFoundError
+    if (error?.message?.includes("Public key not found")) {
+      return {
+        value: 1000n, // Safe default with reveal fees (500 + 374 reveal + buffer)
+        parameters: {
+          gasLimit: 10000n,
+          storageLimit: 300n,
+          amount: 0n,
+          txFee: 1000n,
+        },
+      };
+    } else {
+      // Re-throw other errors
+      throw error;
+    }
+  }
 }
 
 async function operations(
@@ -145,5 +293,6 @@ async function operations(
     sort: pagination.order === "asc" ? "Ascending" : "Descending",
     minHeight: pagination.minHeight,
   });
+
   return [operations, newNextCursor || ""];
 }

package/src/api/types.ts

@@ -1,11 +1,16 @@
-import { AlpacaApi, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { Api, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 
-export type TezosFeeParameters = { gasLimit: bigint; storageLimit: bigint };
-export type TezosFeeEstimation = FeeEstimation;
+export type TezosFeeParameters = {
+  gasLimit: bigint;
+  storageLimit: bigint;
+  amount?: bigint;
+  txFee?: bigint;
+};
+export type TezosFeeEstimation = FeeEstimation & {
+  parameters?: TezosFeeParameters & Record<string, unknown>;
+};
 
 export type TezosSender = { address: string; xpub?: string };
 export type TezosTransactionIntent = TransactionIntent;
 
-export type TezosApi = AlpacaApi & {
-  estimateFees: (transactionIntent: TezosTransactionIntent) => Promise<TezosFeeEstimation>;
-};
+export type TezosApi = Api;

package/src/config.ts

@@ -1,4 +1,8 @@
-import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+import buildCoinConfig, {
+  type CoinConfig,
+  type CurrencyConfig,
+} from "@ledgerhq/coin-framework/config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export type TezosConfig = {
   baker: {
@@ -22,6 +26,9 @@ export type TezosConfig = {
 
 export type TezosCoinConfig = CurrencyConfig & TezosConfig;
 
-const coinConfig = buildCoinConfig<TezosCoinConfig>();
+const coinConfig: {
+  setCoinConfig: (config: CoinConfig<TezosCoinConfig>) => void;
+  getCoinConfig: (currency?: CryptoCurrency) => TezosCoinConfig;
+} = buildCoinConfig<TezosCoinConfig>();
 
 export default coinConfig;

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from "./types";
-
-export { createBridges } from "./bridge/index";
+export * from "./transaction";

package/src/logic/craftTransaction.test.ts

@@ -21,6 +21,7 @@ describe("craftTransaction", () => {
     estimate: {
       reveal: jest.fn(),
     },
+    setProvider: jest.fn(),
   };
 
   beforeEach(() => {

package/src/logic/craftTransaction.ts

@@ -3,6 +3,7 @@ import { getRevealFee } from "@taquito/taquito";
 import coinConfig from "../config";
 import { UnsupportedTransactionMode } from "../types/errors";
 import { getTezosToolkit } from "./tezosToolkit";
+import { createMockSigner } from "../utils";
 
 export type TransactionFee = {
   fees?: string;
@@ -37,6 +38,13 @@ export async function craftTransaction(
 
   const tezosToolkit = getTezosToolkit();
 
+  // Configure signer for Taquito operations (same as in estimateFees)
+  if (publicKey) {
+    tezosToolkit.setProvider({
+      signer: createMockSigner(publicKey.publicKeyHash, publicKey.publicKey),
+    });
+  }
+
   const sourceData = await tezosToolkit.rpc.getContract(address);
   const counter = account.counter ?? Number(sourceData.counter);
 

package/src/logic/estimateFees.integ.test.ts

@@ -22,7 +22,10 @@ describe("estimateFees", () => {
     },
   ];
 
-  it.each(accounts)("returns correct value", async account => {
+  it.each([
+    [accounts[0], "with xpub"],
+    [accounts[1], "without xpub"],
+  ])("returns correct value %s", async (account, _description) => {
     // Given
     const transaction = {
       mode: "send",
@@ -42,7 +45,10 @@ describe("estimateFees", () => {
     });
   });
 
-  it.each(accounts)("returns correct value when useAllAmount", async account => {
+  it.each([
+    [accounts[0], "with xpub"],
+    [accounts[1], "without xpub"],
+  ])("returns correct value when useAllAmount %s", async (account, _description) => {
     // Given
     const transaction = {
       mode: "send",

package/src/logic/estimateFees.ts

@@ -1,11 +1,17 @@
-import { DerivationType } from "@taquito/ledger-signer";
-import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
 import { COST_PER_BYTE, getRevealFee, ORIGINATION_SIZE, Estimate } from "@taquito/taquito";
-import { b58Encode, PrefixV2 } from "@taquito/utils";
+import { validatePublicKey, ValidationResult } from "@taquito/utils";
 import { log } from "@ledgerhq/logs";
 import { getTezosToolkit } from "./tezosToolkit";
 import { TezosOperationMode } from "../types/model";
 import { UnsupportedTransactionMode } from "../types/errors";
+import {
+  createFallbackEstimation,
+  createMockSigner,
+  DUST_MARGIN_MUTEZ,
+  MIN_SUGGESTED_FEE_SMALL_TRANSFER,
+  OP_SIZE_XTZ_TRANSFER,
+  normalizePublicKeyForAddress,
+} from "../utils";
 
 export type CoreAccountInfo = {
   address: string;
@@ -41,54 +47,43 @@ export async function estimateFees({
   account: CoreAccountInfo;
   transaction: CoreTransactionInfo;
 }): Promise<EstimatedFees> {
-  let derivationType: DerivationType;
-  let prefix: PrefixV2;
-  if (account.address?.startsWith("tz1")) {
-    derivationType = DerivationType.ED25519;
-    prefix = PrefixV2.Ed25519PublicKey;
-  } else if (account.address?.startsWith("tz2")) {
-    derivationType = DerivationType.SECP256K1;
-    prefix = PrefixV2.Secp256k1PublicKey;
-  } else if (account.address?.startsWith("tz3")) {
-    derivationType = DerivationType.P256;
-    prefix = PrefixV2.P256PublicKey;
-  } else {
-    throw Error(`Failed detecting key derivation type from address ${account.address}`);
-  }
-
-  const encodedPubKey = b58Encode(
-    compressPublicKey(Buffer.from(account.xpub || "", "hex"), derivationType),
-    prefix,
-  );
+  // Normalize public key (hex -> base58) when provided (may be undefined for unrevealed accounts)
+  // before the device is connected
+  const encodedPubKey = account.xpub
+    ? normalizePublicKeyForAddress(account.xpub, account.address)
+    : undefined;
 
   const tezosToolkit = getTezosToolkit();
-  tezosToolkit.setProvider({
-    signer: {
-      publicKeyHash: async () => account.address,
-      publicKey: async () => encodedPubKey,
-      sign: () => Promise.reject(new Error("unsupported")),
-      secretKey: () => Promise.reject(new Error("unsupported")),
-    },
-  });
+  if (encodedPubKey && validatePublicKey(encodedPubKey) === ValidationResult.VALID) {
+    tezosToolkit.setProvider({ signer: createMockSigner(account.address, encodedPubKey) });
+  } else {
+    tezosToolkit.setProvider({ signer: createMockSigner(account.address, "") });
+  }
 
   const estimation: EstimatedFees = {
-    fees: BigInt(0),
-    gasLimit: BigInt(0),
-    storageLimit: BigInt(0),
-    estimatedFees: BigInt(0),
+    fees: 0n,
+    gasLimit: 0n,
+    storageLimit: 0n,
+    estimatedFees: 0n,
   };
 
   // For legacy compatibility
-  if (account.balance === BigInt(0)) {
-    return transaction.useAllAmount ? { ...estimation, amount: BigInt(0) } : estimation;
+  if (account.balance === 0n) {
+    return transaction.useAllAmount ? { ...estimation, amount: 0n } : estimation;
   }
 
   let amount = transaction.amount;
-  if (transaction.useAllAmount) {
-    amount = BigInt(1); // send max do a pre-estimation with minimum amount (taquito refuses 0)
+  if (transaction.useAllAmount || amount === 0n) {
+    amount = 1n; // send max do a pre-estimation with minimum amount (taquito refuses 0)
   }
 
   try {
+    if (transaction.mode === "send" && !transaction.recipient) {
+      return {
+        ...estimation,
+        ...createFallbackEstimation(),
+      };
+    }
     let estimate: Estimate;
     switch (transaction.mode) {
       case "send":
@@ -96,6 +91,7 @@ export async function estimateFees({
           mutez: true,
           to: transaction.recipient,
           amount: Number(amount),
+          source: account.address, // avoid requiring signer for estimation
           storageLimit: ORIGINATION_SIZE, // https://github.com/TezTech/eztz/blob/master/PROTO_003_FEES.md for originating an account
         });
         break;
@@ -129,16 +125,14 @@ export async function estimateFees({
       // NOTE: from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
       // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
       // we need to increase the gasLimit and fee returned by the estimation
-      const gasBuffer = 500;
       const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
       const increasedFee = (gasBuffer: number, opSize: number) => {
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
-      const incr = increasedFee(gasBuffer, Number(estimate.opSize));
-
-      const maxMinusBuff = maxAmount - (gasBuffer - incr);
-      estimation.amount = maxMinusBuff > 0 ? BigInt(maxMinusBuff) : BigInt(0);
+      const incr = increasedFee(DUST_MARGIN_MUTEZ, Number(estimate.opSize));
 
+      const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
+      estimation.amount = maxMinusBuff > 0 ? BigInt(maxMinusBuff) : 0n;
       estimation.fees = BigInt(estimate.suggestedFeeMutez);
       estimation.gasLimit = BigInt(estimate.gasLimit);
     } else {
@@ -146,6 +140,7 @@ export async function estimateFees({
       estimation.gasLimit = BigInt(estimate.gasLimit);
       estimation.amount = transaction.amount;
     }
+
     estimation.storageLimit = BigInt(estimate.storageLimit);
     estimation.estimatedFees = estimation.fees;
     if (!account.revealed) {
@@ -157,13 +152,109 @@ export async function estimateFees({
       estimation.taquitoError = (e as { id: string }).id;
       log("taquito-error", "taquito got error " + e.id);
     } else if ("status" in e) {
-      // in case of http 400, log & ignore (more case to handle)
-      log("taquito-network-error", String((e as unknown as { message: string }).message || ""), {
-        transaction: transaction,
-      });
-      throw e;
+      const errorMessage = String((e as unknown as { message: string }).message || "");
+      if (
+        errorMessage.includes("Public key not found") ||
+        errorMessage.includes("wallet or contract API")
+      ) {
+        log(
+          "taquito-network-error",
+          "Recipient address not found (new account), using default fees",
+          {
+            transaction: transaction,
+          },
+        );
+        const fallback = createFallbackEstimation();
+        estimation.fees = fallback.fees;
+        estimation.gasLimit = fallback.gasLimit;
+        estimation.storageLimit = fallback.storageLimit;
+        estimation.estimatedFees = fallback.fees;
+        if (!account.revealed) {
+          estimation.estimatedFees =
+            estimation.estimatedFees + BigInt(getRevealFee(account.address));
+        }
+        // Handle useAllAmount also for send mode when estimation falls back
+        if (transaction.useAllAmount) {
+          // Approximate Taquito behavior for send-max using stable constants
+          const suggestedFee =
+            transaction.mode === "send"
+              ? MIN_SUGGESTED_FEE_SMALL_TRANSFER
+              : Number(estimation.fees);
+
+          // For display consistency in tests, align fees to suggestedFee in send-max
+          if (transaction.mode === "send") {
+            estimation.fees = BigInt(suggestedFee);
+            estimation.estimatedFees = BigInt(suggestedFee);
+            if (!account.revealed) {
+              estimation.estimatedFees =
+                estimation.estimatedFees + BigInt(getRevealFee(account.address));
+            }
+          }
+
+          const burnFeeMutez = Number(estimation.storageLimit) * COST_PER_BYTE;
+          const totalFees =
+            suggestedFee + (burnFeeMutez > 0 ? burnFeeMutez - 20 * COST_PER_BYTE : 0);
+
+          const revealFee = account.revealed ? 0 : getRevealFee(account.address);
+          const maxAmount = Number.parseInt(account.balance.toString()) - (totalFees + revealFee);
+
+          const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
+          const incr = OP_SIZE_XTZ_TRANSFER + DUST_MARGIN_MUTEZ * MINIMAL_FEE_PER_GAS_MUTEZ;
+          const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
+          estimation.amount = maxMinusBuff > 0 ? BigInt(Math.floor(maxMinusBuff)) : 0n;
+        } else {
+          // preserve input amount in fallback for readability/tests
+          estimation.amount = transaction.amount;
+        }
+      } else {
+        log("taquito-network-error", errorMessage, {
+          transaction: transaction,
+        });
+        throw e;
+      }
     } else {
-      throw e;
+      const msg = String((e as any).message || "");
+      if (msg.includes("No signer has been configured")) {
+        const fallback = createFallbackEstimation();
+        estimation.fees = fallback.fees;
+        estimation.gasLimit = fallback.gasLimit;
+        estimation.storageLimit = fallback.storageLimit;
+        estimation.estimatedFees = fallback.estimatedFees;
+        if (!account.revealed) {
+          estimation.estimatedFees =
+            estimation.estimatedFees + BigInt(getRevealFee(account.address));
+        }
+        if (transaction.useAllAmount) {
+          const suggestedFee =
+            transaction.mode === "send"
+              ? MIN_SUGGESTED_FEE_SMALL_TRANSFER
+              : Number(estimation.fees);
+
+          if (transaction.mode === "send") {
+            estimation.fees = BigInt(suggestedFee);
+            estimation.estimatedFees = BigInt(suggestedFee);
+            if (!account.revealed) {
+              estimation.estimatedFees =
+                estimation.estimatedFees + BigInt(getRevealFee(account.address));
+            }
+          }
+
+          const burnFeeMutez = Number(estimation.storageLimit) * COST_PER_BYTE;
+          const totalFees =
+            suggestedFee + (burnFeeMutez > 0 ? burnFeeMutez - 20 * COST_PER_BYTE : 0);
+          const revealFee = account.revealed ? 0 : getRevealFee(account.address);
+          const maxAmount = Number.parseInt(account.balance.toString()) - (totalFees + revealFee);
+          const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
+          const incr = OP_SIZE_XTZ_TRANSFER + DUST_MARGIN_MUTEZ * MINIMAL_FEE_PER_GAS_MUTEZ;
+          const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
+          estimation.amount = maxMinusBuff > 0 ? BigInt(Math.floor(maxMinusBuff)) : 0n;
+        } else {
+          // preserve input amount in fallback for readability/tests
+          estimation.amount = transaction.amount;
+        }
+      } else {
+        throw e;
+      }
     }
   }
   return estimation;