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

package/src/logic/validateIntent.test.ts

@@ -0,0 +1,262 @@
+import { validateIntent } from "./validateIntent";
+import * as estimateFeesModule from "./estimateFees";
+import tzktApi from "../network/tzkt";
+import coinConfig from "../config";
+import {
+  RecipientRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+
+describe("validateIntent", () => {
+  const senderAddress = "tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8";
+  const validRecipient = "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx";
+
+  const mockEstimateFees = jest.spyOn(estimateFeesModule, "estimateFees");
+  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,
+      },
+    }));
+
+    mockEstimateFees.mockResolvedValue({
+      fees: BigInt(1000),
+      gasLimit: BigInt(10000),
+      storageLimit: BigInt(0),
+      estimatedFees: BigInt(1000),
+    });
+
+    mockGetAccountByAddress.mockResolvedValue({
+      type: "user",
+      address: senderAddress,
+      publicKey: "edpk...",
+      balance: 5000000,
+      revealed: true,
+      counter: 0,
+      delegationLevel: 0,
+      delegationTime: "2021-01-01T00:00:00Z",
+      numTransactions: 0,
+      firstActivityTime: "2021-01-01T00:00:00Z",
+    });
+  });
+
+  describe("recipient validation", () => {
+    it("should return RecipientRequired error when recipient is missing", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: "",
+        amount: BigInt(1000),
+      });
+
+      expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
+    });
+
+    it("should return InvalidAddress error for invalid recipient", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: "invalid_address",
+        amount: BigInt(1000),
+      });
+
+      expect(result.errors.recipient).toBeInstanceOf(InvalidAddress);
+    });
+
+    it("should return InvalidAddressBecauseDestinationIsAlsoSource when sender equals recipient", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: senderAddress,
+        amount: BigInt(1000),
+      });
+
+      expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+    });
+  });
+
+  describe("amount validation", () => {
+    it("should return AmountRequired error when amount is zero and not useAllAmount", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(0),
+        useAllAmount: false,
+      });
+
+      expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+    });
+
+    it("should not return AmountRequired error when useAllAmount is true", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(0),
+        useAllAmount: true,
+      });
+
+      expect(result.errors.amount).toBeUndefined();
+    });
+  });
+
+  describe("balance validation", () => {
+    it("should return NotEnoughBalance error when amount exceeds balance", async () => {
+      const balance = 1000000; // 1 XTZ
+      const amount = 2000000; // 2 XTZ
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address: senderAddress,
+        publicKey: "edpk...",
+        balance,
+        revealed: true,
+        counter: 0,
+        delegationLevel: 0,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(amount),
+      });
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+    });
+
+    it("should pass validation when amount is within balance", async () => {
+      const balance = 5000000; // 5 XTZ
+      const amount = 1000000; // 1 XTZ
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address: senderAddress,
+        publicKey: "edpk...",
+        balance,
+        revealed: true,
+        counter: 0,
+        delegationLevel: 0,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(amount),
+      });
+
+      expect(result.errors.amount).toBeUndefined();
+      expect(result.amount).toBe(BigInt(amount));
+    });
+  });
+
+  describe("transaction types", () => {
+    it("should pass validation for delegate transaction", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "delegate",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(0),
+      });
+
+      expect(result.errors).toEqual({});
+    });
+
+    it("should pass validation for undelegate transaction", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "undelegate",
+        sender: senderAddress,
+        recipient: "",
+        amount: BigInt(0),
+      });
+
+      expect(result.errors).toEqual({});
+    });
+
+    it("should handle stake intent (mapped to delegate)", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "stake",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount: BigInt(0),
+      });
+
+      expect(result.errors).toEqual({});
+    });
+
+    it("should handle unstake intent (mapped to undelegate)", async () => {
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "unstake",
+        sender: senderAddress,
+        recipient: "",
+        amount: BigInt(0),
+      });
+
+      expect(result.errors).toEqual({});
+    });
+  });
+
+  describe("successful validation", () => {
+    it("should return valid result with correct values", async () => {
+      const amount = BigInt(1000000);
+      const estimatedFees = BigInt(1500);
+
+      mockEstimateFees.mockResolvedValue({
+        fees: BigInt(1000),
+        gasLimit: BigInt(10000),
+        storageLimit: BigInt(0),
+        estimatedFees,
+      });
+
+      const result = await validateIntent({
+        asset: { type: "native" },
+        type: "send",
+        sender: senderAddress,
+        recipient: validRecipient,
+        amount,
+      });
+
+      expect(result).toMatchObject({
+        errors: {},
+        warnings: {},
+        estimatedFees,
+        amount,
+        totalSpent: amount + estimatedFees,
+      });
+    });
+  });
+});

package/src/logic/validateIntent.ts

@@ -0,0 +1,207 @@
+import type { TransactionIntent, TransactionValidation } from "@ledgerhq/coin-framework/api/types";
+import {
+  InvalidAddress,
+  RecipientRequired,
+  RecommendUndelegation,
+  NotEnoughBalance,
+  NotEnoughBalanceToDelegate,
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+} from "@ledgerhq/errors";
+import { validateAddress, ValidationResult } from "@taquito/utils";
+import api from "../network/tzkt";
+import { estimateFees } from "./estimateFees";
+import { InvalidAddressBecauseAlreadyDelegated } from "../types/errors";
+import { mapIntentTypeToTezosMode } from "../utils";
+
+/**
+ * Validates basic recipient and amount for send transactions
+ */
+function validateBasicSendParams(intent: TransactionIntent): Record<string, Error> {
+  const errors: Record<string, Error> = {};
+
+  if (intent.type !== "send") {
+    return errors;
+  }
+
+  if (!intent.recipient) {
+    errors.recipient = new RecipientRequired("");
+  } else if (validateAddress(intent.recipient) !== ValidationResult.VALID) {
+    errors.recipient = new InvalidAddress(undefined, { currencyName: "Tezos" });
+  } else if (intent.sender === intent.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (intent.amount === 0n && !intent.useAllAmount) {
+    errors.amount = new AmountRequired();
+  } else if (intent.amount < 0n) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  return errors;
+}
+
+/**
+ * Validates specific transaction constraints based on account state
+ */
+function validateTransactionConstraints(
+  intent: TransactionIntent,
+  senderInfo: any,
+): Record<string, Error> {
+  const errors: Record<string, Error> = {};
+
+  // send max not allowed on delegated accounts (must undelegate acc first)
+  if (intent.type === "send" && intent.useAllAmount) {
+    if (senderInfo.type === "user" && senderInfo.delegate?.address) {
+      errors.amount = new RecommendUndelegation();
+    }
+  }
+
+  // stake requires non-zero balance
+  if (intent.type === "stake") {
+    const balance = BigInt(senderInfo.balance || "0");
+    if (balance === 0n) {
+      errors.amount = new NotEnoughBalanceToDelegate();
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Maps Taquito-specific errors to our error types
+ */
+function mapTaquitoErrors(taquitoError: string, intentType: string): Record<string, Error> {
+  const errors: Record<string, Error> = {};
+
+  if (taquitoError.endsWith("balance_too_low") || taquitoError.endsWith("subtraction_underflow")) {
+    if (intentType === "stake") {
+      errors.amount = new NotEnoughBalanceToDelegate();
+    } else {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else if (taquitoError.endsWith("delegate.unchanged") && intentType === "stake") {
+    errors.recipient = new InvalidAddressBecauseAlreadyDelegated();
+  } else if (taquitoError.includes("empty_implicit_contract")) {
+    errors.amount = new NotEnoughBalanceToDelegate();
+  } else {
+    errors.amount = new Error(taquitoError);
+  }
+
+  return errors;
+}
+
+/**
+ * Calculates final amounts based on transaction type
+ */
+function calculateAmounts(
+  intent: TransactionIntent,
+  senderInfo: any,
+  estimatedFees: bigint,
+): { amount: bigint; totalSpent: bigint } {
+  if (intent.type === "stake" || intent.type === "unstake") {
+    const amount = BigInt(senderInfo.type === "user" ? senderInfo.balance : 0);
+    return { amount, totalSpent: estimatedFees };
+  }
+
+  if (intent.type === "send" && intent.useAllAmount) {
+    if (senderInfo.type === "user") {
+      const balance = BigInt(senderInfo.balance);
+      const amount = balance > estimatedFees ? balance - estimatedFees : 0n;
+      return { amount, totalSpent: amount + estimatedFees };
+    }
+    return { amount: 0n, totalSpent: 0n };
+  }
+
+  const amount = intent.amount;
+  return { amount, totalSpent: amount + estimatedFees };
+}
+
+/**
+ * Validates balance coverage for the transaction
+ */
+function validateBalanceCoverage(senderInfo: any, totalSpent: bigint): Record<string, Error> {
+  const errors: Record<string, Error> = {};
+
+  if (senderInfo.type === "user") {
+    const accountBalance = BigInt(senderInfo.balance);
+    if (totalSpent > accountBalance) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  return errors;
+}
+
+export async function validateIntent(intent: TransactionIntent): Promise<TransactionValidation> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  let estimatedFees: bigint;
+  let amount: bigint;
+  let totalSpent: bigint;
+
+  // Basic validation for send transactions
+  const basicErrors = validateBasicSendParams(intent);
+  Object.assign(errors, basicErrors);
+
+  if (Object.keys(errors).length > 0) {
+    return { errors, warnings, estimatedFees: 0n, amount: 0n, totalSpent: 0n };
+  }
+
+  try {
+    // Get sender account information
+    const senderInfo = await api.getAccountByAddress(intent.sender);
+    if (senderInfo.type !== "user") throw new Error("unexpected account type");
+
+    // Validate transaction-specific constraints
+    const constraintErrors = validateTransactionConstraints(intent, senderInfo);
+    Object.assign(errors, constraintErrors);
+
+    if (Object.keys(errors).length > 0) {
+      return { errors, warnings, estimatedFees: 0n, amount: 0n, totalSpent: 0n };
+    }
+
+    // Estimate fees
+    if (senderInfo.revealed) {
+      const estimation = await estimateFees({
+        account: {
+          address: intent.sender,
+          revealed: senderInfo.revealed,
+          balance: BigInt(senderInfo.balance),
+          xpub: intent.senderPublicKey ?? senderInfo.publicKey,
+        },
+        transaction: {
+          mode: mapIntentTypeToTezosMode(intent.type),
+          recipient: intent.recipient,
+          amount: intent.amount,
+          useAllAmount: !!intent.useAllAmount,
+        },
+      });
+      estimatedFees = estimation.estimatedFees;
+
+      // Handle Taquito errors
+      if (estimation.taquitoError) {
+        const taquitoErrors = mapTaquitoErrors(estimation.taquitoError, intent.type);
+        Object.assign(errors, taquitoErrors);
+      }
+    } else {
+      estimatedFees = 2000n;
+    }
+
+    // Calculate final amounts
+    const amounts = calculateAmounts(intent, senderInfo, estimatedFees);
+    amount = amounts.amount;
+    totalSpent = amounts.totalSpent;
+
+    // Final balance validation
+    const balanceErrors = validateBalanceCoverage(senderInfo, totalSpent);
+    Object.assign(errors, balanceErrors);
+  } catch (e) {
+    errors.estimation = e as Error;
+    estimatedFees = 0n;
+    amount = intent.amount;
+    totalSpent = intent.amount;
+  }
+
+  return { errors, warnings, estimatedFees, amount, totalSpent };
+}

package/src/{bridge/transaction.ts → transaction.ts}

@@ -1,5 +1,5 @@
 import { BigNumber } from "bignumber.js";
-import type { Transaction, TransactionRaw } from "../types";
+import type { Transaction, TransactionRaw } from "./types";
 import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
 import {
   fromTransactionCommonRaw,
@@ -58,9 +58,9 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
       fees: new BigNumber(networkInfo.fees),
     },
     fees: tr.fees ? new BigNumber(tr.fees) : null,
-    gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : null,
-    storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : null,
-    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : null,
+    gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : undefined,
+    storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : undefined,
+    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : undefined,
     taquitoError: tr.taquitoError,
   };
 };

package/src/types/bridge.fixture.ts

@@ -47,6 +47,7 @@ export function createFixtureAccount(account?: Partial<TezosAccount>): TezosAcco
     swapHistory: [],
 
     tezosResources,
+    stakingPositions: account?.stakingPositions || [],
   };
 }
 

package/src/types/bridge.ts

@@ -7,6 +7,7 @@ import type {
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
+import type { Stake } from "@ledgerhq/coin-framework/api/index";
 import type { BigNumber } from "bignumber.js";
 import { TezosOperationMode } from "./model";
 
@@ -79,7 +80,11 @@ export type Delegation = {
   sendShouldWarnDelegation: boolean;
 };
 
-export type TezosAccount = Account & { tezosResources: TezosResources };
+export type StakingPosition = Stake;
+export type TezosAccount = Account & {
+  tezosResources: TezosResources;
+  stakingPositions: StakingPosition[];
+};
 export function isTezosAccount(account: Account): account is TezosAccount {
   return "tezosResources" in account;
 }

package/src/utils.ts

@@ -0,0 +1,115 @@
+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,
+};
+
+/**
+ * Dust margin in mutez to prevent transaction failures on send max operations
+ * This ensures a small safety buffer remains in the account after send max
+ * Based on production behavior where ~281-287 mutez typically remain
+ * Increased to 500 to handle edge cases and fee estimation variations
+ */
+export const DUST_MARGIN_MUTEZ = 500;
+
+/**
+ * Suggested fee returned by Taquito for a minimal amount pre-estimation (mutez)
+ * Used as a stable fallback for send-max when RPC estimation is unavailable.
+ */
+export const MIN_SUGGESTED_FEE_SMALL_TRANSFER = 489;
+
+/**
+ * Typical operation size (bytes) for a simple XTZ transfer used to approximate
+ * the increased fee component when computing send-max in fallback mode.
+ * Chosen to match Taquito’s behavior closely in integration tests.
+ */
+export const OP_SIZE_XTZ_TRANSFER = 154;
+
+/**
+ * Helper function to map generic staking intents to Tezos operation modes
+ */
+export function mapIntentTypeToTezosMode(intentType: string): "send" | "delegate" | "undelegate" {
+  switch (intentType) {
+    case "stake":
+    case "delegate":
+      return "delegate";
+    case "unstake":
+    case "undelegate":
+      return "undelegate";
+    default:
+      return "send";
+  }
+}
+
+/**
+ * Creates a mock signer for Taquito operations (estimation and crafting)
+ */
+export function createMockSigner(publicKeyHash: string, publicKey: string) {
+  return {
+    publicKeyHash: async () => publicKeyHash,
+    publicKey: async () => publicKey,
+    sign: () => Promise.reject(new Error("unsupported")),
+    secretKey: () => Promise.reject(new Error("unsupported")),
+  };
+}
+
+/**
+ * Normalize a Tezos public key to base58 format (edpk/sppk/p2pk) based on the
+ * sender address prefix (tz1/tz2/tz3). Accepts either an already base58-encoded
+ * key or a hex key returned by the Ledger app. Returns undefined if input is
+ * empty or cannot be parsed.
+ */
+export function normalizePublicKeyForAddress(
+  maybeKey: string | undefined,
+  address: string,
+): string | undefined {
+  if (!maybeKey) return undefined;
+
+  // If it's already a valid base58 public key, keep it
+  if (validatePublicKey(maybeKey) === ValidationResult.VALID) return maybeKey;
+
+  // Attempt to convert hex → base58 according to address curve
+  try {
+    const pkHex = maybeKey.trim().toLowerCase();
+    if (pkHex === "") return undefined;
+    const keyBuf = Buffer.from(pkHex, "hex");
+
+    // Choose curve/prefix from address tz1/tz2/tz3
+    // default are values for tz1 and fallbacks to it
+    let derivationType: DerivationType = DerivationType.ED25519;
+    let prefix: PrefixV2 = PrefixV2.Ed25519PublicKey;
+
+    if (address.startsWith("tz2")) {
+      derivationType = DerivationType.SECP256K1;
+      prefix = PrefixV2.Secp256k1PublicKey;
+    } else if (address.startsWith("tz3")) {
+      derivationType = DerivationType.P256;
+      prefix = PrefixV2.P256PublicKey;
+    }
+
+    return b58Encode(compressPublicKey(keyBuf, derivationType), prefix);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Creates default fallback estimation values
+ */
+export function createFallbackEstimation() {
+  return {
+    fees: DEFAULT_LIMITS.BASE_FEE,
+    gasLimit: DEFAULT_LIMITS.GAS,
+    storageLimit: DEFAULT_LIMITS.STORAGE,
+    estimatedFees: DEFAULT_LIMITS.BASE_FEE,
+  };
+}

package/lib/bridge/broadcast.d.ts

@@ -1,4 +0,0 @@
-import { AccountBridge } from "@ledgerhq/types-live";
-import { Transaction } from "../types";
-export declare const broadcast: AccountBridge<Transaction>["broadcast"];
-//# sourceMappingURL=broadcast.d.ts.map

package/lib/bridge/broadcast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../src/bridge/broadcast.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAmB,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,eAAO,MAAM,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,WAAW,CAO7D,CAAC"}

package/lib/bridge/broadcast.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.broadcast = void 0;
-const operation_1 = require("@ledgerhq/coin-framework/operation");
-const logic_1 = require("../logic");
-const broadcast = async ({ signedOperation: { operation, signature }, }) => {
-    const hash = await (0, logic_1.broadcast)(signature);
-    return (0, operation_1.patchOperationWithHash)(operation, hash);
-};
-exports.broadcast = broadcast;
-//# sourceMappingURL=broadcast.js.map

package/lib/bridge/broadcast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.js","sourceRoot":"","sources":["../../src/bridge/broadcast.ts"],"names":[],"mappings":";;;AAAA,kEAA4E;AAG5E,oCAAuD;AAEhD,MAAM,SAAS,GAA4C,KAAK,EAAE,EACvE,eAAe,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,GAG1C,EAAE,EAAE;IACH,MAAM,IAAI,GAAG,MAAM,IAAA,iBAAc,EAAC,SAAS,CAAC,CAAC;IAC7C,OAAO,IAAA,kCAAsB,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC,CAAC;AAPW,QAAA,SAAS,aAOpB"}

package/lib/bridge/broadcast.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=broadcast.test.d.ts.map

package/lib/bridge/broadcast.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.test.d.ts","sourceRoot":"","sources":["../../src/bridge/broadcast.test.ts"],"names":[],"mappings":""}