@ledgerhq/coin-tezos 6.6.0-nightly.1 → 6.6.0

package/src/logic/getStakes.test.ts

@@ -1,145 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/validateIntent.test.ts

@@ -1,262 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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 };
-}