@ledgerhq/coin-vechain 2.9.1-nightly.1 → 2.9.2-nightly.0

package/src/bridge/createTransaction.test.ts

@@ -0,0 +1,201 @@
+import { createTransaction } from "./createTransaction";
+import { Account } from "@ledgerhq/types-live";
+import { generateNonce } from "../common-logic";
+import { MAINNET_CHAIN_TAG } from "../types";
+import BigNumber from "bignumber.js";
+
+// Mock dependencies
+jest.mock("../common-logic");
+jest.mock("../types", () => ({
+  ...jest.requireActual("../types"),
+  MAINNET_CHAIN_TAG: 74,
+}));
+
+const mockedGenerateNonce = jest.mocked(generateNonce);
+
+describe("createTransaction", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    id: "vechain:1:0x123:",
+    seedIdentifier: "seed123",
+    derivationMode: "" as any,
+    index: 0,
+    freshAddress: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+    freshAddressPath: "44'/818'/0'/0/0",
+    used: true,
+    balance: new BigNumber("5000000000000000000"),
+    spendableBalance: new BigNumber("5000000000000000000"),
+    creationDate: new Date("2022-01-01"),
+    blockHeight: 12345,
+    currency: {} as any,
+    operationsCount: 10,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date("2022-01-01"),
+    balanceHistoryCache: { HOUR: {}, DAY: {}, WEEK: {} } as any,
+    swapHistory: [],
+    subAccounts: [],
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGenerateNonce.mockReturnValue("0x1234567890abcdef");
+  });
+
+  it("should create a transaction with correct default values", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result).toEqual({
+      family: "vechain",
+      body: {
+        chainTag: 74,
+        blockRef: "0x0000000000000000",
+        expiration: 18,
+        clauses: [],
+        maxFeePerGas: 0,
+        maxPriorityFeePerGas: 0,
+        gas: "0",
+        dependsOn: null,
+        nonce: "0x1234567890abcdef",
+      },
+      amount: new BigNumber(0),
+      estimatedFees: "0",
+      recipient: "",
+      useAllAmount: false,
+    });
+  });
+
+  it("should use MAINNET_CHAIN_TAG for chainTag", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.chainTag).toBe(MAINNET_CHAIN_TAG);
+    expect(result.body.chainTag).toBe(74);
+  });
+
+  it("should generate a unique nonce for each transaction", () => {
+    mockedGenerateNonce
+      .mockReturnValueOnce("0x1111111111111111")
+      .mockReturnValueOnce("0x2222222222222222")
+      .mockReturnValueOnce("0x3333333333333333");
+
+    const tx1 = createTransaction(mockAccount);
+    const tx2 = createTransaction(mockAccount);
+    const tx3 = createTransaction(mockAccount);
+
+    expect(tx1.body.nonce).toBe("0x1111111111111111");
+    expect(tx2.body.nonce).toBe("0x2222222222222222");
+    expect(tx3.body.nonce).toBe("0x3333333333333333");
+    expect(mockedGenerateNonce).toHaveBeenCalledTimes(3);
+  });
+
+  it("should create transaction with empty clauses array", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.clauses).toEqual([]);
+    expect(Array.isArray(result.body.clauses)).toBe(true);
+  });
+
+  it("should set default expiration to 18", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.expiration).toBe(18);
+  });
+
+  it("should set default blockRef to zero", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.blockRef).toBe("0x0000000000000000");
+  });
+
+  it("should set default gas values to zero", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.maxFeePerGas).toBe(0);
+    expect(result.body.maxPriorityFeePerGas).toBe(0);
+    expect(result.body.gas).toBe("0");
+  });
+
+  it("should set dependsOn to null", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.body.dependsOn).toBe(null);
+  });
+
+  it("should create BigNumber amount with zero value", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.amount).toBeInstanceOf(BigNumber);
+    expect(result.amount.isZero()).toBe(true);
+    expect(result.amount.toString()).toBe("0");
+  });
+
+  it("should set default recipient to empty string", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.recipient).toBe("");
+  });
+
+  it("should set useAllAmount to false", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.useAllAmount).toBe(false);
+  });
+
+  it("should set estimatedFees to zero string", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.estimatedFees).toBe("0");
+    expect(typeof result.estimatedFees).toBe("string");
+  });
+
+  it("should set family to vechain", () => {
+    const result = createTransaction(mockAccount);
+
+    expect(result.family).toBe("vechain");
+  });
+
+  it("should call generateNonce exactly once", () => {
+    createTransaction(mockAccount);
+
+    expect(mockedGenerateNonce).toHaveBeenCalledTimes(1);
+    expect(mockedGenerateNonce).toHaveBeenCalledWith();
+  });
+
+  it("should handle different nonce formats from generateNonce", () => {
+    const testNonces = [
+      "0x0000000000000000",
+      "0xffffffffffffffff",
+      "0x123456789abcdef0",
+      "0xa1b2c3d4e5f67890",
+    ];
+
+    testNonces.forEach(nonce => {
+      mockedGenerateNonce.mockReturnValueOnce(nonce);
+      const result = createTransaction(mockAccount);
+      expect(result.body.nonce).toBe(nonce);
+    });
+  });
+
+  it("should create independent transaction objects", () => {
+    mockedGenerateNonce
+      .mockReturnValueOnce("0x1111111111111111")
+      .mockReturnValueOnce("0x2222222222222222");
+
+    const tx1 = createTransaction(mockAccount);
+    const tx2 = createTransaction(mockAccount);
+
+    // Modify one transaction
+    tx1.amount = new BigNumber(100);
+    tx1.recipient = "0x123";
+    tx1.body.clauses.push({
+      to: "0x123",
+      value: "100",
+      data: "0x",
+    });
+
+    // Verify the other transaction is unchanged
+    expect(tx2.amount.isZero()).toBe(true);
+    expect(tx2.recipient).toBe("");
+    expect(tx2.body.clauses).toEqual([]);
+  });
+});

package/src/bridge/createTransaction.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { generateNonce } from "../common-logic";
-import { Transaction, DEFAULT_GAS_COEFFICIENT, MAINNET_CHAIN_TAG } from "../types";
+import { Transaction, MAINNET_CHAIN_TAG } from "../types";
 
 /**
  * Create an empty VET or VTHO transaction
@@ -18,7 +18,8 @@ export const createTransaction: AccountBridge<Transaction>["createTransaction"]
       blockRef: "0x0000000000000000",
       expiration: 18,
       clauses: [],
-      gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+      maxFeePerGas: 0,
+      maxPriorityFeePerGas: 0,
       gas: "0",
       dependsOn: null,
       nonce: generateNonce(),

package/src/bridge/estimateMaxSpendable.test.ts

@@ -0,0 +1,319 @@
+import BigNumber from "bignumber.js";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { calculateGasFees } from "../common-logic";
+import { Transaction } from "../types";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+
+// Mock dependencies
+jest.mock("../common-logic");
+
+const mockedCalculateGasFees = jest.mocked(calculateGasFees);
+
+describe("estimateMaxSpendable", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    id: "vechain:1:0x123:",
+    seedIdentifier: "seed123",
+    derivationMode: "" as any,
+    index: 0,
+    freshAddress: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+    freshAddressPath: "44'/818'/0'/0/0",
+    used: true,
+    balance: new BigNumber("5000000000000000000"), // 5 VET
+    spendableBalance: new BigNumber("5000000000000000000"),
+    creationDate: new Date("2022-01-01"),
+    blockHeight: 12345,
+    currency: {} as any,
+    operationsCount: 10,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date("2022-01-01"),
+    balanceHistoryCache: { HOUR: {}, DAY: {}, WEEK: {} } as any,
+    swapHistory: [],
+    subAccounts: [],
+  };
+
+  const mockTokenAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: "vechain:1:0x123:+vtho",
+    parentId: "vechain:1:0x123:",
+    token: {} as any,
+    balance: new BigNumber("1000000000000000000000"), // 1000 VTHO
+    spendableBalance: new BigNumber("1000000000000000000000"),
+    creationDate: new Date("2022-01-01"),
+    operationsCount: 5,
+    operations: [],
+    pendingOperations: [],
+    balanceHistoryCache: { HOUR: {}, DAY: {}, WEEK: {} } as any,
+    swapHistory: [],
+  };
+
+  const mockTransaction: Transaction = {
+    family: "vechain",
+    recipient: "0x456789012345678901234567890123456789abcd",
+    amount: new BigNumber("1000000000000000000"),
+    estimatedFees: "210000000000000000",
+    body: {
+      chainTag: 74,
+      blockRef: "0x00000000000b2bce",
+      expiration: 18,
+      clauses: [],
+      maxFeePerGas: 10000000000000,
+      maxPriorityFeePerGas: 1000000000000,
+      gas: 21000,
+      dependsOn: null,
+      nonce: "0x12345678",
+    },
+  } as Transaction;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedCalculateGasFees.mockResolvedValue({
+      estimatedGas: 21000,
+      estimatedGasFees: new BigNumber("210000000000000000"), // 0.21 VET
+      maxFeePerGas: 10000000000000,
+      maxPriorityFeePerGas: 1000000000000,
+    });
+  });
+
+  describe("Account type handling", () => {
+    it("should return account balance for Account type", async () => {
+      const result = await estimateMaxSpendable({
+        account: mockAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("5000000000000000000"));
+      expect(mockedCalculateGasFees).not.toHaveBeenCalled();
+    });
+
+    it("should return account balance when transaction is missing", async () => {
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: undefined,
+      } as any);
+
+      expect(result).toEqual(new BigNumber("1000000000000000000000"));
+      expect(mockedCalculateGasFees).not.toHaveBeenCalled();
+    });
+
+    it("should return account balance when transaction is null", async () => {
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: null,
+      } as any);
+
+      expect(result).toEqual(new BigNumber("1000000000000000000000"));
+      expect(mockedCalculateGasFees).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Token account handling", () => {
+    it("should calculate max spendable for token account with sufficient balance", async () => {
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("999790000000000000000")); // 1000 - 0.21 VTHO
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(mockTransaction, true);
+    });
+
+    it("should return zero when gas fees exceed token balance", async () => {
+      mockedCalculateGasFees.mockResolvedValue({
+        estimatedGas: 21000,
+        estimatedGasFees: new BigNumber("2000000000000000000000"), // 2000 VET (more than balance)
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+      });
+
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("0"));
+    });
+
+    it("should return zero when gas fees equal token balance", async () => {
+      mockedCalculateGasFees.mockResolvedValue({
+        estimatedGas: 21000,
+        estimatedGasFees: new BigNumber("1000000000000000000000"), // Exactly 1000 VET
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+      });
+
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("0"));
+    });
+
+    it("should handle very small gas fees", async () => {
+      mockedCalculateGasFees.mockResolvedValue({
+        estimatedGas: 21000,
+        estimatedGasFees: new BigNumber("1"), // 1 wei
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+      });
+
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("999999999999999999999")); // 1000 VTHO - 1 wei
+    });
+  });
+
+  describe("calculateGasFees integration", () => {
+    it("should call calculateGasFees with correct parameters for token account", async () => {
+      await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(mockTransaction, true);
+      expect(mockedCalculateGasFees).toHaveBeenCalledTimes(1);
+    });
+
+    it("should handle calculateGasFees errors", async () => {
+      const error = new Error("Gas calculation failed");
+      mockedCalculateGasFees.mockRejectedValue(error);
+
+      await expect(
+        estimateMaxSpendable({
+          account: mockTokenAccount,
+          transaction: mockTransaction,
+        }),
+      ).rejects.toThrow("Gas calculation failed");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle zero balance token account", async () => {
+      const zeroBalanceTokenAccount: TokenAccount = {
+        ...mockTokenAccount,
+        balance: new BigNumber("0"),
+        spendableBalance: new BigNumber("0"),
+      };
+
+      const result = await estimateMaxSpendable({
+        account: zeroBalanceTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("0"));
+    });
+
+    it("should handle zero balance account", async () => {
+      const zeroBalanceAccount: Account = {
+        ...mockAccount,
+        balance: new BigNumber("0"),
+        spendableBalance: new BigNumber("0"),
+      };
+
+      const result = await estimateMaxSpendable({
+        account: zeroBalanceAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("0"));
+    });
+
+    it("should handle very large balances", async () => {
+      const largeBalanceTokenAccount: TokenAccount = {
+        ...mockTokenAccount,
+        balance: new BigNumber("1000000000000000000000000"), // 1M tokens
+      };
+
+      const result = await estimateMaxSpendable({
+        account: largeBalanceTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("999999790000000000000000")); // 1M - 0.21
+    });
+
+    it("should handle different transaction types", async () => {
+      const tokenTransaction: Transaction = {
+        ...mockTransaction,
+        subAccountId: "vechain:1:0x123:+vtho",
+      };
+
+      await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: tokenTransaction,
+      });
+
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(tokenTransaction, true);
+    });
+  });
+
+  describe("BigNumber operations", () => {
+    it("should handle precise BigNumber calculations", async () => {
+      const preciseBalanceTokenAccount: TokenAccount = {
+        ...mockTokenAccount,
+        balance: new BigNumber("1000000000000000000001"), // 1000.000000000000000001 tokens
+      };
+
+      mockedCalculateGasFees.mockResolvedValue({
+        estimatedGas: 21000,
+        estimatedGasFees: new BigNumber("1"), // 1 wei
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+      });
+
+      const result = await estimateMaxSpendable({
+        account: preciseBalanceTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("1000000000000000000000")); // Exactly 1000 tokens
+    });
+
+    it("should handle decimal precision in calculations", async () => {
+      mockedCalculateGasFees.mockResolvedValue({
+        estimatedGas: 21000,
+        estimatedGasFees: new BigNumber("123456789012345"), // Non-round number
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+      });
+
+      const result = await estimateMaxSpendable({
+        account: mockTokenAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(new BigNumber("999999876543210987655")); // Precise subtraction
+    });
+  });
+
+  describe("account type validation", () => {
+    it("should correctly identify Account type", async () => {
+      const accountTypeAccount = { ...mockAccount, type: "Account" as const };
+
+      const result = await estimateMaxSpendable({
+        account: accountTypeAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(result).toEqual(accountTypeAccount.balance);
+      expect(mockedCalculateGasFees).not.toHaveBeenCalled();
+    });
+
+    it("should correctly identify TokenAccount type", async () => {
+      const tokenTypeAccount = { ...mockTokenAccount, type: "TokenAccount" as const };
+
+      const result = await estimateMaxSpendable({
+        account: tokenTypeAccount,
+        transaction: mockTransaction,
+      });
+
+      expect(mockedCalculateGasFees).toHaveBeenCalled();
+      expect(result).toEqual(new BigNumber("999790000000000000000"));
+    });
+  });
+});