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

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;

package/src/logic/getBalance.ts

@@ -6,5 +6,5 @@ import api from "../network/tzkt";
  */
 export async function getBalance(address: string): Promise<bigint> {
   const apiAccount = await api.getAccountByAddress(address);
-  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : BigInt(-1);
+  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : -1n;
 }

package/src/logic/getStakes.test.ts

@@ -0,0 +1,145 @@
+import { createApi } from "../api/index";
+import tzktApi from "../network/tzkt";
+import coinConfig from "../config";
+
+describe("getStakes", () => {
+  const api = createApi({
+    baker: { url: "http://baker.example.com" },
+    explorer: { url: "http://tezos.explorer.com", maxTxQuery: 100 },
+    node: { url: "http://tezos.node.com" },
+    fees: {
+      minGasLimit: 600,
+      minRevealGasLimit: 300,
+      minStorageLimit: 0,
+      minFees: 500,
+      minEstimatedFees: 500,
+    },
+  });
+
+  const mockGetAccountByAddress = jest.spyOn(tzktApi, "getAccountByAddress");
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    coinConfig.setCoinConfig(() => ({
+      status: { type: "active" },
+      baker: { url: "http://baker.example.com" },
+      explorer: { url: "http://tezos.explorer.com", maxTxQuery: 100 },
+      node: { url: "http://tezos.node.com" },
+      fees: {
+        minGasLimit: 600,
+        minRevealGasLimit: 300,
+        minStorageLimit: 0,
+        minFees: 500,
+        minEstimatedFees: 500,
+      },
+    }));
+  });
+
+  describe("account types", () => {
+    it("should return empty stakes for non-delegated account", async () => {
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address: "tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq",
+        publicKey: "edpk...",
+        balance: 1000000,
+        revealed: true,
+        counter: 0,
+        delegationLevel: 0,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes("tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq");
+
+      expect(result.items).toEqual([]);
+    });
+
+    it("should return empty stakes for non user account", async () => {
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "empty",
+        address: "tz1EmptyAccount",
+        counter: 0,
+      });
+
+      const result = await api.getStakes("tz1EmptyAccount");
+
+      expect(result.items).toEqual([]);
+    });
+  });
+
+  describe("delegated accounts", () => {
+    it("should return stake for delegated account", async () => {
+      const address = "tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8";
+      const delegateAddress = "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx";
+      const balance = 5000000;
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address,
+        publicKey: "edpk...",
+        balance,
+        revealed: true,
+        counter: 0,
+        delegate: {
+          alias: "Test Delegate",
+          address: delegateAddress,
+          active: true,
+        },
+        delegationLevel: 100,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 10,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes(address);
+
+      expect(result.items).toEqual([
+        expect.objectContaining({
+          uid: address,
+          address,
+          delegate: delegateAddress,
+          state: "active",
+          asset: { type: "native" },
+          amount: BigInt(balance),
+        }),
+      ]);
+    });
+
+    it("should handle account with zero balance but delegation", async () => {
+      const address = "tz1ZeroBalanceAccount";
+      const delegateAddress = "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx";
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address,
+        publicKey: "edpk...",
+        balance: 0,
+        revealed: true,
+        counter: 0,
+        delegate: {
+          alias: "Test Delegate",
+          address: delegateAddress,
+          active: true,
+        },
+        delegationLevel: 100,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes(address);
+
+      expect(result.items).toHaveLength(1);
+      expect(result.items[0]).toMatchObject({
+        uid: address,
+        address,
+        delegate: delegateAddress,
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(0),
+      });
+    });
+  });
+});

package/src/logic/getStakes.ts

@@ -0,0 +1,20 @@
+import type { Cursor, Page, Stake } from "@ledgerhq/coin-framework/api/types";
+import api from "../network/tzkt";
+
+export async function getStakes(address: string, _cursor?: Cursor): Promise<Page<Stake>> {
+  // tezos exposes a single staking position via delegation when a delegate is set
+  const accountInfo = await api.getAccountByAddress(address);
+  if (accountInfo.type !== "user" || !accountInfo.delegate?.address) return { items: [] };
+  return {
+    items: [
+      {
+        uid: address,
+        address,
+        delegate: accountInfo.delegate.address,
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(accountInfo.balance ?? 0),
+      },
+    ],
+  };
+}

package/src/logic/index.ts

@@ -7,3 +7,5 @@ export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";
 export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
+export { validateIntent } from "./validateIntent";
+export { getStakes } from "./getStakes";

package/src/logic/listOperations.test.ts

@@ -83,45 +83,50 @@ describe("listOperations", () => {
   };
 
   it.each([
-    ["undelegate", undelegate],
-    ["delegate", delegate],
-    ["transfer", transfer],
-  ])("should return %s operation with proper recipient list", async (_label, operation) => {
-    // Given
-    mockNetworkGetTransactions.mockResolvedValue([operation]);
-    // When
-    const [results] = await listOperations("any address", options);
-    // Then
-    expect(results).toEqual([
-      {
-        id: `${operation.hash}-${operation.id}`,
-        asset: { type: "native" },
-        details: {
-          counter: operation.counter,
-          gasLimit: operation.gasLimit,
-          storageLimit: operation.storageLimit,
-        },
-        senders: [someSenderAddress],
-        recipients: [someDestinationAddress],
-        tx: {
-          block: {
-            hash: operation.block,
-            height: operation.level,
-            time: new Date(operation.timestamp),
+    ["undelegate", undelegate, "DELEGATE", "DELEGATE"],
+    ["delegate", delegate, "UNDELEGATE", "UNDELEGATE"],
+    ["transfer", transfer, "OUT", undefined],
+  ])(
+    "should return %s operation with proper recipient list",
+    async (_label, operation, expectedType, expectedLedgerOpType) => {
+      // Given
+      mockNetworkGetTransactions.mockResolvedValue([operation]);
+      // When
+      const [results] = await listOperations("any address", options);
+      // Then
+      expect(results).toEqual([
+        {
+          id: `${operation.hash}-${operation.id}`,
+          asset: { type: "native" },
+          details: {
+            counter: operation.counter,
+            gasLimit: operation.gasLimit,
+            storageLimit: operation.storageLimit,
+            status: operation.status,
+            ledgerOpType: expectedLedgerOpType,
+          },
+          senders: [someSenderAddress],
+          recipients: [someDestinationAddress],
+          tx: {
+            block: {
+              hash: operation.block,
+              height: operation.level,
+              time: new Date(operation.timestamp),
+            },
+            date: new Date(operation.timestamp),
+            hash: operation.hash,
+            fees: BigInt(
+              (operation.allocationFee ?? 0) +
+                (operation.bakerFee ?? 0) +
+                (operation.storageFee ?? 0),
+            ),
           },
-          date: new Date(operation.timestamp),
-          hash: operation.hash,
-          fees: BigInt(
-            (operation.allocationFee ?? 0) +
-              (operation.bakerFee ?? 0) +
-              (operation.storageFee ?? 0),
-          ),
+          type: expectedType,
+          value: BigInt(operation.amount),
         },
-        type: operation.type,
-        value: BigInt(operation.amount),
-      },
-    ]);
-  });
+      ]);
+    },
+  );
 
   it.each([
     ["undelegate", undelegate],
@@ -142,23 +147,28 @@ describe("listOperations", () => {
   );
 
   it.each([
-    ["undelegate", undelegate],
-    ["delegate", delegate],
-    ["transfer", transfer],
-    ["reveal", reveal],
-  ])("should return %s operation with expected details", async (_label, operation) => {
-    // Given
-    mockNetworkGetTransactions.mockResolvedValue([operation]);
-    // When
-    const [results, _] = await listOperations("any address", options);
-    // Then
-    expect(results.length).toEqual(1);
-    expect(results[0].details).toEqual({
-      counter: 65214462,
-      gasLimit: 4,
-      storageLimit: 5,
-    });
-  });
+    ["undelegate", undelegate, "DELEGATE"],
+    ["delegate", delegate, "UNDELEGATE"],
+    ["transfer", transfer, undefined],
+    ["reveal", reveal, "REVEAL"],
+  ])(
+    "should return %s operation with expected details",
+    async (_label, operation, expectedLedgerOpType) => {
+      // Given
+      mockNetworkGetTransactions.mockResolvedValue([operation]);
+      // When
+      const [results, _] = await listOperations("any address", options);
+      // Then
+      expect(results.length).toEqual(1);
+      expect(results[0].details).toEqual({
+        counter: 65214462,
+        gasLimit: 4,
+        storageLimit: 5,
+        status: operation.status,
+        ledgerOpType: expectedLedgerOpType,
+      });
+    },
+  );
 
   it.each([
     { ...undelegate, newDelegate: null, prevDelegate: null },