@ledgerhq/coin-tezos 6.6.0 → 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;
@@ -24,11 +24,18 @@ jest.mock("../logic", () => ({
   rawEncode: () => Promise.resolve("tz1heMGVHQnx7ALDcDKqez8fan64Eyicw4DJ"),
 }));
 
-jest
-  .spyOn(networkApi, "getAccountByAddress")
-  .mockImplementation((_adress: string) =>
-    Promise.resolve({ type: "user", balance: 1000 } as APIAccount),
-  );
+jest.spyOn(networkApi, "getAccountByAddress").mockResolvedValue({
+  type: "user",
+  balance: 1000,
+  revealed: true,
+  address: "tz1test",
+  publicKey: "edpktest",
+  counter: 0,
+  delegationLevel: 0,
+  delegationTime: "2021-01-01T00:00:00Z",
+  numTransactions: 0,
+  firstActivityTime: "2021-01-01T00:00:00Z",
+} as APIAccount);
 
 const api = createApi({
   baker: {
@@ -94,12 +101,28 @@ describe("Testing craftTransaction function", () => {
   beforeEach(() => jest.clearAllMocks());
 
   it("should use estimated fees when user does not provide them for crafting a transaction ", async () => {
-    logicEstimateFees.mockResolvedValue({ estimatedFees: DEFAULT_ESTIMATED_FEES });
-    await api.craftTransaction({ type: "send", sender: {} } as TezosTransactionIntent);
+    logicEstimateFees.mockResolvedValue({
+      estimatedFees: DEFAULT_ESTIMATED_FEES,
+      gasLimit: DEFAULT_GAS_LIMIT,
+      storageLimit: DEFAULT_STORAGE_LIMIT,
+    });
+    await api.craftTransaction({
+      intentType: "transaction",
+      type: "send",
+      sender: "tz1test",
+      recipient: "tz1recipient",
+      amount: 1000n,
+    } as TransactionIntent);
     expect(logicEstimateFees).toHaveBeenCalledTimes(1);
     expect(logicCraftTransactionMock).toHaveBeenCalledWith(
-      expect.any(Object),
-      expect.objectContaining({ fee: { fees: DEFAULT_ESTIMATED_FEES.toString() } }),
+      expect.objectContaining({ address: "tz1test" }),
+      expect.objectContaining({
+        fee: expect.objectContaining({
+          fees: DEFAULT_ESTIMATED_FEES.toString(),
+          gasLimit: DEFAULT_GAS_LIMIT.toString(),
+          storageLimit: DEFAULT_STORAGE_LIMIT.toString(),
+        }),
+      }),
     );
   });
 
@@ -110,10 +133,23 @@ describe("Testing craftTransaction function", () => {
         estimatedFees: DEFAULT_ESTIMATED_FEES,
         gasLimit: DEFAULT_GAS_LIMIT,
         storageLimit: DEFAULT_STORAGE_LIMIT,
+        parameters: {
+          gasLimit: DEFAULT_GAS_LIMIT,
+          storageLimit: DEFAULT_STORAGE_LIMIT,
+        },
       });
-      await api.craftTransaction({ type: "send", sender: {} } as TezosTransactionIntent, {
-        value: customFees,
-      });
+      await api.craftTransaction(
+        {
+          intentType: "transaction",
+          type: "send",
+          sender: "tz1test",
+          recipient: "tz1recipient",
+          amount: 1000n,
+        } as TransactionIntent,
+        {
+          value: customFees,
+        },
+      );
       expect(logicEstimateFees).toHaveBeenCalledTimes(1);
       expect(logicCraftTransactionMock).toHaveBeenCalledWith(
         expect.any(Object),
@@ -138,7 +174,13 @@ describe("Testing estimateFees function", () => {
       gasLimit: DEFAULT_GAS_LIMIT,
       storageLimit: DEFAULT_STORAGE_LIMIT,
     });
-    const result = await api.estimateFees({ type: "send", sender: {} } as TezosTransactionIntent);
+    const result = await api.estimateFees({
+      intentType: "transaction",
+      type: "send",
+      sender: "tz1test",
+      recipient: "tz1recipient",
+      amount: 1000n,
+    } as TransactionIntent);
     expect(result).toEqual({
       value: DEFAULT_ESTIMATED_FEES,
       parameters: {
@@ -149,9 +191,44 @@ describe("Testing estimateFees function", () => {
   });
 
   it("should throw taquito errors", async () => {
-    logicEstimateFees.mockResolvedValue({ taquitoError: "test" });
+    logicEstimateFees.mockResolvedValue({
+      estimatedFees: DEFAULT_ESTIMATED_FEES,
+      gasLimit: DEFAULT_GAS_LIMIT,
+      storageLimit: DEFAULT_STORAGE_LIMIT,
+      taquitoError: "test",
+    });
     await expect(
-      api.estimateFees({ type: "send", sender: {} } as TezosTransactionIntent),
+      api.estimateFees({
+        intentType: "transaction",
+        type: "send",
+        sender: "tz1test",
+        recipient: "tz1recipient",
+        amount: 1000n,
+      } as TransactionIntent),
     ).rejects.toThrow("Fees estimation failed: test");
   });
+
+  it("should not throw for delegate.unchanged errors", async () => {
+    logicEstimateFees.mockResolvedValue({
+      estimatedFees: DEFAULT_ESTIMATED_FEES,
+      gasLimit: DEFAULT_GAS_LIMIT,
+      storageLimit: DEFAULT_STORAGE_LIMIT,
+      taquitoError: "proto.022-PsRiotum.delegate.unchanged",
+    });
+    const result = await api.estimateFees({
+      intentType: "staking",
+      type: "delegate",
+      sender: "tz1test",
+      recipient: "tz1validator",
+      amount: 0n,
+    } as TransactionIntent);
+
+    expect(result).toEqual({
+      value: DEFAULT_ESTIMATED_FEES,
+      parameters: {
+        gasLimit: DEFAULT_GAS_LIMIT,
+        storageLimit: DEFAULT_STORAGE_LIMIT,
+      },
+    });
+  });
 });

package/src/api/index.ts

@@ -21,11 +21,22 @@ import {
   lastBlock,
   listOperations,
   rawEncode,
+  validateIntent,
+  getStakes,
 } from "../logic";
+import { getTezosToolkit } from "../logic/tezosToolkit";
 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,
+  hasEmptyBalance,
+  mapIntentTypeToTezosMode,
+  normalizePublicKeyForAddress,
+} from "../utils";
 
 export function createApi(config: TezosConfig): TezosApi {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
@@ -34,35 +45,66 @@ 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,
     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 +117,214 @@ 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 = needsReveal ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0) : totalFee;
+  } else if (estimation.parameters?.txFee !== undefined) {
+    txFee = Number(estimation.parameters.txFee);
+  } else {
+    const calculatedTxFee = needsReveal
+      ? Math.max(totalFee - getRevealFee(transactionIntent.sender), 0)
+      : totalFee;
+    txFee = calculatedTxFee;
+  }
+
+  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
+  const config = coinConfig.getCoinConfig();
+  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")) {
+      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: totalFee,
+        parameters: {
+          gasLimit: 10000n,
+          storageLimit,
+          amount: 0n,
+          txFee: baseTxFee,
+        },
+      };
+    } else {
+      // Re-throw other errors
+      throw error;
+    }
+  }
 }
 
 async function operations(
@@ -145,5 +337,6 @@ async function operations(
     sort: pagination.order === "asc" ? "Ascending" : "Descending",
     minHeight: pagination.minHeight,
   });
+
   return [operations, newNextCursor || ""];
 }

package/src/api/types.ts

@@ -1,11 +1,15 @@
-import { AlpacaApi, FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { Api, FeeEstimation } 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",