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

package/src/logic/listOperations.ts

@@ -10,7 +10,6 @@ import {
   isAPITransactionType,
 } from "../network/types";
 import { Operation } from "@ledgerhq/coin-framework/api/types";
-// import { TezosAsset } from "../api/types";
 
 /**
  * Returns list of "Transfer", "Delegate" and "Undelegate" Operations associated to an account.
@@ -38,25 +37,58 @@ export async function listOperations(
     options = { ...options, lastId: JSON.parse(token) };
   }
   const operations = await tzkt.getAccountOperations(address, options);
-  const lastOperation = operations.slice(-1)[0];
+
+  // Apply limit after fetching since tzkt API might not respect the limit parameter
+  const limitedOperations = limit ? operations.slice(0, limit) : operations;
+
+  const lastOperation = limitedOperations.at(-1);
   // it's important to get the last id from the **unfiltered** operation list
   // otherwise we might miss operations
   const nextToken = lastOperation ? JSON.stringify(lastOperation?.id) : "";
-  const filteredOperations = operations
+  const filteredOperations = limitedOperations
     .filter(op => isAPITransactionType(op) || isAPIDelegationType(op) || isAPIRevealType(op))
-    .reduce((acc, op) => acc.concat(convertOperation(address, op)), [] as Operation[]);
+    .filter(op => {
+      // Filter out failed incoming tx
+      const hasFailed = op.status !== "applied";
+      if (hasFailed && isAPITransactionType(op)) {
+        const isIn = op.target?.address === address;
+        if (isIn) {
+          return false;
+        }
+      }
+      return true;
+    })
+    .map(op => convertOperation(address, op))
+    .flat();
   const sortedOperations = filteredOperations.sort(
     (a, b) => b.tx.date.getTime() - a.tx.date.getTime(),
   );
   return [sortedOperations, nextToken];
 }
 
+/**
+ * Helper function to get the ledgerOpType for an operation
+ */
+function getLedgerOpType(
+  operation: APITransactionType | APIDelegationType | APIRevealType,
+  normalizedType: Operation["type"],
+): string | undefined {
+  if (isAPIDelegationType(operation)) {
+    return operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
+  } else if (isAPIRevealType(operation)) {
+    return "REVEAL";
+  } else if (normalizedType === "FEES") {
+    return "FEES";
+  }
+  return undefined;
+}
+
 // note that "initiator" of APITransactionType is never used in the conversion
 function convertOperation(
   address: string,
   operation: APITransactionType | APIDelegationType | APIRevealType,
 ): Operation {
-  const { hash, sender, type, id } = operation;
+  const { hash, sender, id } = operation;
 
   let targetAddress = undefined;
   if (isAPITransactionType(operation)) {
@@ -66,22 +98,48 @@ function convertOperation(
     targetAddress = operation?.newDelegate?.address || operation?.prevDelegate?.address;
   }
 
-  const recipients = [];
+  const recipients = targetAddress ? [targetAddress] : [];
   if (!targetAddress) {
     log("coin:tezos", "(logic/operations): No target address found for operation", operation);
-  } else {
-    recipients.push(targetAddress);
   }
 
   const senders = sender?.address ? [sender.address] : [];
 
-  const amount = isAPIRevealType(operation) ? BigInt(0) : BigInt(operation.amount);
+  const amount = isAPIRevealType(operation) ? 0n : BigInt(operation.amount);
 
   const fee =
     BigInt(operation.storageFee ?? 0) +
     BigInt(operation.bakerFee ?? 0) +
     BigInt(operation.allocationFee ?? 0);
 
+  // Determine operation type inline
+  let normalizedType: Operation["type"];
+  if (isAPIDelegationType(operation)) {
+    normalizedType = operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
+  } else if (isAPITransactionType(operation)) {
+    const isOut = sender?.address === address;
+    const isIn = targetAddress === address;
+
+    if ((isOut && isIn) || amount === 0n) {
+      normalizedType = "FEES";
+    } else if (isOut) {
+      normalizedType = "OUT";
+    } else if (isIn) {
+      normalizedType = "IN";
+    } else {
+      normalizedType = "OUT"; // fallback
+    }
+  } else if (isAPIRevealType(operation)) {
+    normalizedType = "REVEAL";
+  } else {
+    // fallback for unknown types
+    log("coin:tezos", "(logic/operations): Unknown operation type, defaulting to OUT");
+    normalizedType = "OUT";
+  }
+
+  // Tezos uses "applied" for every sucess operation (something else=failed )
+  const hasFailed = operation.status && operation.status !== "applied";
+
   return {
     id: `${hash ?? ""}-${id}`,
     asset: { type: "native" },
@@ -97,7 +155,7 @@ function convertOperation(
       },
       date: new Date(operation.timestamp),
     },
-    type: type,
+    type: normalizedType,
     value: amount,
     senders: senders,
     recipients: recipients,
@@ -105,6 +163,8 @@ function convertOperation(
       counter: operation.counter,
       gasLimit: operation.gasLimit,
       storageLimit: operation.storageLimit,
+      status: hasFailed ? "failed" : operation.status,
+      ledgerOpType: getLedgerOpType(operation, normalizedType),
     },
   };
 }

package/src/logic/validateIntent.test.ts

@@ -0,0 +1,274 @@
+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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "transaction",
+        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({
+        intentType: "staking",
+        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({
+        intentType: "staking",
+        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({
+        intentType: "staking",
+        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({
+        intentType: "staking",
+        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({
+        intentType: "transaction",
+        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;
 }