@ledgerhq/coin-vechain 2.9.1-nightly.1 → 2.10.0-nightly.3

package/src/bridge/prepareTransaction.ts

@@ -1,12 +1,11 @@
 import { Account } from "@ledgerhq/types-live";
-import { Transaction as VeChainThorTransaction } from "thor-devkit";
 import {
   calculateTransactionInfo,
-  isValid,
   calculateClausesVet,
   calculateClausesVtho,
+  parseAddress,
 } from "../common-logic";
-import { Transaction } from "../types";
+import { Transaction, VechainSDKTransactionClause } from "../types";
 import { getBlockRef } from "../network";
 
 /**
@@ -19,15 +18,19 @@ export const prepareTransaction = async (
   account: Account,
   transaction: Transaction,
 ): Promise<Transaction> => {
-  const { amount, isTokenAccount, estimatedFees, estimatedGas } = await calculateTransactionInfo(
-    account,
-    transaction,
-  );
+  const {
+    amount,
+    isTokenAccount,
+    estimatedFees,
+    estimatedGas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  } = await calculateTransactionInfo(account, transaction);
 
   let blockRef = "";
 
-  let clauses: Array<VeChainThorTransaction.Clause> = [];
-  if (transaction.recipient && isValid(transaction.recipient)) {
+  let clauses: Array<VechainSDKTransactionClause> = [];
+  if (transaction.recipient && parseAddress(transaction.recipient)) {
     blockRef = await getBlockRef();
     if (isTokenAccount) {
       clauses = await calculateClausesVtho(transaction.recipient, amount);
@@ -36,6 +39,13 @@ export const prepareTransaction = async (
     }
   }
 
-  const body = { ...transaction.body, gas: estimatedGas, blockRef, clauses };
+  const body = {
+    ...transaction.body,
+    gas: estimatedGas,
+    blockRef,
+    clauses,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  };
   return { ...transaction, body, amount, estimatedFees };
 };

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,354 @@
+import { buildSignOperation } from "./signOperation";
+import { buildOptimisticOperation } from "./buildOptimisticOperatioin";
+import { VechainSDKTransaction, VechainSigner, Transaction } from "../types";
+import { Account, DeviceId, SignOperationEvent } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import BigNumber from "bignumber.js";
+
+// Mock dependencies
+jest.mock("./buildOptimisticOperatioin");
+jest.mock("../types", () => ({
+  ...jest.requireActual("../types"),
+  VechainSDKTransaction: {
+    of: jest.fn(),
+  },
+}));
+
+const mockedBuildOptimisticOperation = jest.mocked(buildOptimisticOperation);
+const mockedVechainSDKTransaction = jest.mocked(VechainSDKTransaction);
+
+describe("buildSignOperation", () => {
+  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: [],
+  };
+
+  const mockTransaction: Transaction = {
+    family: "vechain",
+    recipient: "0x456789012345678901234567890123456789abcd",
+    amount: new BigNumber("1000000000000000000"),
+    estimatedFees: "210000000000000000",
+    body: {
+      chainTag: 74,
+      blockRef: "0x00000000000b2bce",
+      expiration: 18,
+      clauses: [
+        {
+          to: "0x456789012345678901234567890123456789abcd",
+          value: "1000000000000000000",
+          data: "0x",
+        },
+      ],
+      maxFeePerGas: 10000000000000,
+      maxPriorityFeePerGas: 1000000000000,
+      gas: 21000,
+      dependsOn: null,
+      nonce: "0x12345678",
+    },
+  } as Transaction;
+
+  const mockDeviceId: DeviceId = "mock-device-id";
+
+  const mockSigner: VechainSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  };
+
+  const mockSignerContext: SignerContext<VechainSigner> = jest.fn();
+
+  const mockUnsignedTransaction = {
+    encoded: Buffer.from("mockencoded", "hex"),
+  };
+
+  const mockOperation = {
+    id: "vechain:1:0x123:0xtxhash:OUT",
+    hash: "",
+    type: "OUT" as const,
+    value: new BigNumber("1000000000000000000"),
+    fee: new BigNumber("210000000000000000"),
+    blockHash: null,
+    blockHeight: null,
+    senders: ["0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4"],
+    recipients: ["0x456789012345678901234567890123456789abcd"],
+    accountId: "vechain:1:0x123:",
+    date: new Date("2022-01-01"),
+    extra: {},
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedVechainSDKTransaction.of.mockReturnValue(mockUnsignedTransaction as any);
+    mockedBuildOptimisticOperation.mockResolvedValue(mockOperation);
+    (mockSigner.signTransaction as jest.Mock).mockResolvedValue(Buffer.from("signature123", "hex"));
+    (mockSignerContext as jest.Mock).mockImplementation((deviceId, callback) =>
+      callback(mockSigner),
+    );
+  });
+
+  it("should emit correct sequence of events for successful signing", async () => {
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    const events: SignOperationEvent[] = [];
+    const promise = new Promise<void>((resolve, reject) => {
+      observable.subscribe({
+        next: event => events.push(event),
+        complete: resolve,
+        error: reject,
+      });
+    });
+
+    await promise;
+
+    expect(events).toHaveLength(3);
+    expect(events[0]).toEqual({ type: "device-signature-requested" });
+    expect(events[1]).toEqual({ type: "device-signature-granted" });
+    expect(events[2]).toEqual({
+      type: "signed",
+      signedOperation: {
+        operation: mockOperation,
+        signature: "",
+        rawData: mockTransaction,
+      },
+    });
+  });
+
+  it("should create unsigned transaction from transaction body", async () => {
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({ complete: resolve, error: reject });
+    });
+
+    expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(mockTransaction.body);
+  });
+
+  it("should call signer with correct parameters", async () => {
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({ complete: resolve, error: reject });
+    });
+
+    expect(mockSignerContext).toHaveBeenCalledWith(mockDeviceId, expect.any(Function));
+    expect(mockSigner.signTransaction).toHaveBeenCalledWith(
+      mockAccount.freshAddressPath,
+      mockUnsignedTransaction.encoded.toString("hex"),
+    );
+  });
+
+  it("should build optimistic operation with correct parameters", async () => {
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({ complete: resolve, error: reject });
+    });
+
+    expect(mockedBuildOptimisticOperation).toHaveBeenCalledWith(mockAccount, mockTransaction);
+  });
+
+  it("should convert signature buffer to hex string", async () => {
+    const signatureBuffer = Buffer.from([0x12, 0x34, 0x56, 0x78]);
+    (mockSigner.signTransaction as jest.Mock).mockResolvedValue(signatureBuffer);
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    const events: SignOperationEvent[] = [];
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({
+        next: event => events.push(event),
+        complete: resolve,
+        error: reject,
+      });
+    });
+
+    const signedEvent = events.find(e => e.type === "signed") as any;
+    expect(signedEvent.signedOperation.signature).toBe("12345678");
+  });
+
+  it("should handle signer errors", async () => {
+    const signerError = new Error("Hardware wallet error");
+    (mockSigner.signTransaction as jest.Mock).mockRejectedValue(signerError);
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await expect(
+      new Promise<void>((resolve, reject) => {
+        observable.subscribe({ complete: resolve, error: reject });
+      }),
+    ).rejects.toThrow("Hardware wallet error");
+  });
+
+  it("should handle VechainSDKTransaction creation errors", async () => {
+    const transactionError = new Error("Invalid transaction format");
+    mockedVechainSDKTransaction.of.mockImplementation(() => {
+      throw transactionError;
+    });
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await expect(
+      new Promise<void>((resolve, reject) => {
+        observable.subscribe({ complete: resolve, error: reject });
+      }),
+    ).rejects.toThrow("Invalid transaction format");
+  });
+
+  it("should handle buildOptimisticOperation errors", async () => {
+    const operationError = new Error("Failed to build operation");
+    mockedBuildOptimisticOperation.mockRejectedValue(operationError);
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await expect(
+      new Promise<void>((resolve, reject) => {
+        observable.subscribe({ complete: resolve, error: reject });
+      }),
+    ).rejects.toThrow("Failed to build operation");
+  });
+
+  it("should handle signerContext errors", async () => {
+    const contextError = new Error("Signer context failed");
+    (mockSignerContext as jest.Mock).mockRejectedValue(contextError);
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await expect(
+      new Promise<void>((resolve, reject) => {
+        observable.subscribe({ complete: resolve, error: reject });
+      }),
+    ).rejects.toThrow("Signer context failed");
+  });
+
+  it("should work with different device IDs", async () => {
+    const deviceIds = ["device1", "device2", "device3"];
+
+    for (const deviceId of deviceIds) {
+      const signOperation = buildSignOperation(mockSignerContext);
+      const observable = signOperation({
+        account: mockAccount,
+        transaction: mockTransaction,
+        deviceId,
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        observable.subscribe({ complete: resolve, error: reject });
+      });
+
+      expect(mockSignerContext).toHaveBeenCalledWith(deviceId, expect.any(Function));
+    }
+  });
+
+  it("should include rawData as transaction in signed operation", async () => {
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: mockTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    const events: SignOperationEvent[] = [];
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({
+        next: event => events.push(event),
+        complete: resolve,
+        error: reject,
+      });
+    });
+
+    const signedEvent = events.find(e => e.type === "signed") as any;
+    expect(signedEvent.signedOperation.rawData).toBe(mockTransaction);
+  });
+
+  it("should handle different transaction types", async () => {
+    const tokenTransaction: Transaction = {
+      ...mockTransaction,
+      subAccountId: "vechain:1:0x123:+vtho",
+      body: {
+        ...mockTransaction.body,
+        clauses: [
+          {
+            to: "0x0000000000000000000000000000456e65726779",
+            value: "0",
+            data: "0xa9059cbb000000000000000000000000456789012345678901234567890123456789abcd0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+          },
+        ],
+      },
+    };
+
+    const signOperation = buildSignOperation(mockSignerContext);
+    const observable = signOperation({
+      account: mockAccount,
+      transaction: tokenTransaction,
+      deviceId: mockDeviceId,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({ complete: resolve, error: reject });
+    });
+
+    expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(tokenTransaction.body);
+  });
+});

package/src/bridge/signOperation.ts

@@ -1,9 +1,9 @@
 import { Observable } from "rxjs";
-import { Transaction as ThorTransaction } from "thor-devkit";
 import type { Account, AccountBridge, DeviceId, SignOperationEvent } from "@ledgerhq/types-live";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { buildOptimisticOperation } from "./buildOptimisticOperatioin";
 import type { Transaction, VechainSigner } from "../types";
+import { VechainSDKTransaction } from "../types";
 
 /**
  * Sign Transaction with Ledger hardware
@@ -22,14 +22,17 @@ export const buildSignOperation =
     new Observable(o => {
       // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
       async function main() {
-        const unsigned = new ThorTransaction(transaction.body);
+        const unsigned = VechainSDKTransaction.of(transaction.body);
 
         o.next({
           type: "device-signature-requested",
         });
 
         const signature = await signerContext(deviceId, signer =>
-          signer.signTransaction(account.freshAddressPath, unsigned.encode().toString("hex")),
+          signer.signTransaction(
+            account.freshAddressPath,
+            Buffer.from(unsigned.encoded).toString("hex"),
+          ),
         );
 
         o.next({ type: "device-signature-granted" });

package/src/bridge/synchronisation.ts

@@ -9,10 +9,10 @@ import {
 
 import { getAccount, getLastBlockHeight, getOperations, getTokenOperations } from "../network";
 import { findTokenById, getTokenById } from "@ledgerhq/cryptoassets/tokens";
-import { VTHO_ADDRESS } from "../contracts/constants";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { Account } from "@ledgerhq/types-live";
 import { isAccountEmpty } from "./helpers";
+import { VTHO_ADDRESS } from "@vechain/sdk-core";
 
 export const getAccountShape: GetAccountShape<Account> = async info => {
   const { initialAccount, currency, derivationMode } = info;