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

package/src/signer/signMessage.test.ts

@@ -0,0 +1,329 @@
+import { signMessage } from "./signMessage";
+import { VechainSDKTransaction, VechainSigner } from "../types";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+// Mock dependencies
+jest.mock("../types", () => ({
+  ...jest.requireActual("../types"),
+  VechainSDKTransaction: {
+    of: jest.fn(),
+  },
+}));
+
+const mockedVechainSDKTransaction = jest.mocked(VechainSDKTransaction);
+
+describe("signMessage", () => {
+  const mockDeviceId = "mock-device-id";
+  const mockPath = "44'/818'/0'/0/0";
+
+  const mockSigner: VechainSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  };
+
+  const mockSignerContext: SignerContext<VechainSigner> = jest.fn();
+
+  const mockTransactionObject = {
+    chainTag: 74,
+    blockRef: "0x00000000000b2bce",
+    expiration: 18,
+    clauses: [
+      {
+        to: "0x456789012345678901234567890123456789abcd",
+        value: "1000000000000000000",
+        data: "0x",
+      },
+    ],
+    maxFeePerGas: 10000000000000,
+    maxPriorityFeePerGas: 1000000000000,
+    gas: 21000,
+    dependsOn: null,
+    nonce: "0x12345678",
+  };
+
+  const mockUnsignedTransaction = {
+    encoded: Buffer.from("mockencodedtransaction", "hex"),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedVechainSDKTransaction.of.mockReturnValue(mockUnsignedTransaction as any);
+    (mockSigner.signTransaction as jest.Mock).mockResolvedValue(Buffer.from("signature123", "hex"));
+    (mockSignerContext as jest.Mock).mockImplementation((deviceId, callback) =>
+      callback(mockSigner),
+    );
+  });
+
+  describe("message parsing", () => {
+    it("should parse valid JSON message", async () => {
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      const result = await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      // JSON parsing is handled internally by the function
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(mockTransactionObject);
+      expect(result).toBe("");
+    });
+
+    it("should parse valid JSON rawMessage when message is empty", async () => {
+      const rawMessage = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      const result = await signMessageFn(mockDeviceId, mockPath, "", rawMessage);
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(mockTransactionObject);
+      expect(result).toBe("");
+    });
+
+    it("should prefer message over rawMessage when both are provided", async () => {
+      const message = JSON.stringify(mockTransactionObject);
+      const differentRawMessage = JSON.stringify({ different: "object" });
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, differentRawMessage);
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(mockTransactionObject);
+    });
+
+    it("should throw error for invalid JSON message", async () => {
+      const invalidMessage = "invalid json {";
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await expect(signMessageFn(mockDeviceId, mockPath, invalidMessage, "")).rejects.toThrow(
+        "Message is not a valid JSON object",
+      );
+    });
+
+    it("should throw error for invalid JSON rawMessage", async () => {
+      const invalidRawMessage = "invalid json {";
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await expect(signMessageFn(mockDeviceId, mockPath, "", invalidRawMessage)).rejects.toThrow(
+        "Message is not a valid JSON object",
+      );
+    });
+
+    it("should throw error when both message and rawMessage are empty", async () => {
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await expect(signMessageFn(mockDeviceId, mockPath, "", "")).rejects.toThrow(
+        "Message is not a valid JSON object",
+      );
+    });
+  });
+
+  describe("transaction creation", () => {
+    it("should create VechainSDKTransaction from parsed object", async () => {
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(mockTransactionObject);
+    });
+
+    it("should handle VechainSDKTransaction creation errors", async () => {
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      mockedVechainSDKTransaction.of.mockImplementation(() => {
+        throw new Error("Invalid transaction");
+      });
+
+      await expect(signMessageFn(mockDeviceId, mockPath, message, "")).rejects.toThrow(
+        "Message is not a valid JSON object",
+      );
+    });
+
+    it("should handle different transaction structures", async () => {
+      const tokenTransaction = {
+        ...mockTransactionObject,
+        clauses: [
+          {
+            to: "0x0000000000000000000000000000456e65726779",
+            value: "0",
+            data: "0xa9059cbb000000000000000000000000456789012345678901234567890123456789abcd0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+          },
+        ],
+      };
+
+      const message = JSON.stringify(tokenTransaction);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(tokenTransaction);
+    });
+  });
+
+  describe("signing process", () => {
+    it("should call signer with correct parameters", async () => {
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockSignerContext).toHaveBeenCalledWith(mockDeviceId, expect.any(Function));
+      expect(mockSigner.signTransaction).toHaveBeenCalledWith(
+        mockPath,
+        mockUnsignedTransaction.encoded.toString("hex"),
+      );
+    });
+
+    it("should convert encoded transaction to hex string", async () => {
+      const customEncoded = Buffer.from("customtransaction", "utf8");
+      const customUnsigned = { encoded: customEncoded };
+      mockedVechainSDKTransaction.of.mockReturnValue(customUnsigned as any);
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockSigner.signTransaction).toHaveBeenCalledWith(
+        mockPath,
+        customEncoded.toString("hex"),
+      );
+    });
+
+    it("should return signature as hex string", async () => {
+      const signatureBuffer = Buffer.from([0x12, 0x34, 0x56, 0x78]);
+      (mockSigner.signTransaction as jest.Mock).mockResolvedValue(signatureBuffer);
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      const result = await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(result).toBe("12345678");
+    });
+
+    it("should handle signer errors", async () => {
+      const signerError = new Error("Hardware wallet error");
+      (mockSigner.signTransaction as jest.Mock).mockRejectedValue(signerError);
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await expect(signMessageFn(mockDeviceId, mockPath, message, "")).rejects.toThrow(
+        "Hardware wallet error",
+      );
+    });
+
+    it("should handle signerContext errors", async () => {
+      const contextError = new Error("Signer context failed");
+      (mockSignerContext as jest.Mock).mockRejectedValue(contextError);
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await expect(signMessageFn(mockDeviceId, mockPath, message, "")).rejects.toThrow(
+        "Signer context failed",
+      );
+    });
+  });
+
+  describe("different input scenarios", () => {
+    it("should handle different device IDs", async () => {
+      const deviceIds = ["device1", "device2", "device3"];
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      for (const deviceId of deviceIds) {
+        await signMessageFn(deviceId, mockPath, message, "");
+        expect(mockSignerContext).toHaveBeenCalledWith(deviceId, expect.any(Function));
+      }
+    });
+
+    it("should handle different derivation paths", async () => {
+      const paths = ["44'/818'/0'/0/0", "44'/818'/1'/0/0", "44'/818'/0'/0/1"];
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      for (const path of paths) {
+        await signMessageFn(mockDeviceId, path, message, "");
+        expect(mockSigner.signTransaction).toHaveBeenCalledWith(path, expect.any(String));
+      }
+    });
+
+    it("should handle complex transaction objects", async () => {
+      const complexTransaction = {
+        ...mockTransactionObject,
+        clauses: [
+          {
+            to: "0x456789012345678901234567890123456789abcd",
+            value: "1000000000000000000",
+            data: "0x",
+          },
+          {
+            to: "0x0000000000000000000000000000456e65726779",
+            value: "0",
+            data: "0xa9059cbb",
+          },
+        ],
+        dependsOn: "0xprevious123",
+        gas: 50000,
+      };
+
+      const message = JSON.stringify(complexTransaction);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(complexTransaction);
+    });
+
+    it("should handle minimal transaction objects", async () => {
+      const minimalTransaction = {
+        chainTag: 74,
+        blockRef: "0x0000000000000000",
+        expiration: 18,
+        clauses: [],
+        maxFeePerGas: 0,
+        maxPriorityFeePerGas: 0,
+        gas: 0,
+        dependsOn: null,
+        nonce: "0x00000000",
+      };
+
+      const message = JSON.stringify(minimalTransaction);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(mockedVechainSDKTransaction.of).toHaveBeenCalledWith(minimalTransaction);
+    });
+  });
+
+  describe("signature formatting", () => {
+    it("should handle different signature lengths", async () => {
+      const signatures = [
+        Buffer.from("12", "hex"),
+        Buffer.from("1234567890abcdef", "hex"),
+        Buffer.from("ff".repeat(32), "hex"),
+      ];
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      for (const signature of signatures) {
+        (mockSigner.signTransaction as jest.Mock).mockResolvedValueOnce(signature);
+        const result = await signMessageFn(mockDeviceId, mockPath, message, "");
+        expect(result).toBe(signature.toString("hex"));
+      }
+    });
+
+    it("should handle empty signature buffer", async () => {
+      const emptySignature = Buffer.alloc(0);
+      (mockSigner.signTransaction as jest.Mock).mockResolvedValue(emptySignature);
+
+      const message = JSON.stringify(mockTransactionObject);
+      const signMessageFn = signMessage(mockSignerContext);
+
+      const result = await signMessageFn(mockDeviceId, mockPath, message, "");
+
+      expect(result).toBe("");
+    });
+  });
+});

package/src/signer/signMessage.ts

@@ -1,21 +1,20 @@
-import { Transaction as ThorTransaction } from "thor-devkit";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { VechainSigner } from "../types";
+import { VechainSDKTransaction, VechainSigner } from "../types";
 
 export const signMessage =
   (signerContext: SignerContext<VechainSigner>) =>
   async (deviceId: string, path: string, message: string, rawMessage: string) => {
     let messageObj;
-    let unsigned: ThorTransaction;
+    let unsigned: VechainSDKTransaction;
     try {
       if (message) messageObj = JSON.parse(message);
       else messageObj = JSON.parse(rawMessage);
-      unsigned = new ThorTransaction(messageObj);
+      unsigned = VechainSDKTransaction.of(messageObj);
     } catch (e) {
       throw new Error("Message is not a valid JSON object");
     }
     const result = await signerContext(deviceId, signer =>
-      signer.signTransaction(path, unsigned.encode().toString("hex")),
+      signer.signTransaction(path, Buffer.from(unsigned.encoded).toString("hex")),
     );
 
     return result.toString("hex");

package/src/test/bridgeDatasetTest.ts

@@ -1,14 +1,18 @@
 import BigNumber from "bignumber.js";
-import type { AccountRaw, CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type {
+  AccountRaw,
+  CurrenciesData,
+  DatasetTest,
+  TransactionStatusCommon,
+} from "@ledgerhq/types-live";
 import type { Transaction } from "../types";
 import { fromTransactionRaw } from "../bridge/transaction";
-import { DEFAULT_GAS_COEFFICIENT, MAINNET_CHAIN_TAG } from "../types";
+import { MAINNET_CHAIN_TAG } from "../types";
 import { vechain1, vechain3 } from "../datasets";
 import { generateNonce } from "../common-logic";
 
 import vechainScanAccounts1 from "../datasets/vechain.scanAccounts.1";
 import { AmountRequired, NotEnoughBalance } from "@ledgerhq/errors";
-import VIP180 from "../contracts/abis/VIP180";
 import { CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 import { NotEnoughVTHO } from "../errors";
 import {
@@ -16,6 +20,7 @@ import {
   setSupportedCurrencies,
 } from "@ledgerhq/coin-framework/currencies/index";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { ABIContract, VIP180_ABI } from "@vechain/sdk-core";
 
 const listSupported = listSupportedCurrencies();
 listSupported.push(getCryptoCurrencyById("vechain"));
@@ -36,7 +41,7 @@ const vechain: CurrenciesData<Transaction> = {
             family: "vechain",
             estimatedFees: "210000000000000000",
             recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-            amount: "1000000000000000000",
+            amount: (1e18).toString(), // 1 VET
             body: {
               chainTag: MAINNET_CHAIN_TAG,
               blockRef: "0x00634a0c856ec1db",
@@ -44,22 +49,26 @@ const vechain: CurrenciesData<Transaction> = {
               clauses: [
                 {
                   to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-                  value: "1000000000000000000",
+                  value: (1e18).toString(), // 1 VET
                   data: "0x",
                 },
               ],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
           }),
-          expectedStatus: {
-            amount: new BigNumber("1000000000000000000"),
-            estimatedFees: new BigNumber("210000000000000000"),
-            totalSpent: new BigNumber("1000000000000000000"),
-            errors: {},
-            warnings: {},
+          expectedStatus: (_account, _, status): Partial<TransactionStatusCommon> => {
+            const estimatedFees = status.estimatedFees;
+            return {
+              amount: new BigNumber(1e18), // 1 VET
+              estimatedFees, // fees are calculated during preparation and therefore cannot be guessed without mocks
+              totalSpent: new BigNumber(1e18),
+              errors: {},
+              warnings: {},
+            };
           },
         },
         {
@@ -70,7 +79,7 @@ const vechain: CurrenciesData<Transaction> = {
               "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
             estimatedFees: "515180000000000000",
             recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-            amount: "1000000000000000000",
+            amount: (1e19).toString(), // 10 VTHO
             body: {
               chainTag: MAINNET_CHAIN_TAG,
               blockRef: "0x00634a0c856ec1db",
@@ -79,24 +88,30 @@ const vechain: CurrenciesData<Transaction> = {
                 {
                   to: "0x0000000000000000000000000000456e65726779",
                   value: 0,
-                  data: VIP180.transfer.encode(
-                    "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-                    "9000000000000000000",
-                  ),
+                  data: ABIContract.ofAbi(VIP180_ABI)
+                    .encodeFunctionInput("transfer", [
+                      "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                      "9000000000000000000",
+                    ])
+                    .toString(),
                 },
               ],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
           }),
-          expectedStatus: {
-            amount: new BigNumber("1000000000000000000"),
-            estimatedFees: new BigNumber("515180000000000000"),
-            totalSpent: new BigNumber("1515180000000000000"),
-            errors: {},
-            warnings: {},
+          expectedStatus: (_account, _, status): Partial<TransactionStatusCommon> => {
+            const estimatedFees = status.estimatedFees;
+            return {
+              amount: new BigNumber(1e19), // 10 VTHO
+              estimatedFees, // fees are calculated during preparation and therefore cannot be guessed without mocks
+              totalSpent: new BigNumber(1e19).plus(estimatedFees), // fees are calculated during preparation and therefore cannot be guessed without mocks
+              errors: {},
+              warnings: {},
+            };
           },
         },
         {
@@ -111,8 +126,9 @@ const vechain: CurrenciesData<Transaction> = {
               blockRef: "0x00634a0c856ec1db",
               expiration: 18,
               clauses: [{ to: "", value: 0, data: "0x" }],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
@@ -130,7 +146,7 @@ const vechain: CurrenciesData<Transaction> = {
             family: "vechain",
             estimatedFees: "210000000000000000",
             recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-            amount: "20000000000000000000",
+            amount: (2e19).toString(), // 20 VET
             body: {
               chainTag: MAINNET_CHAIN_TAG,
               blockRef: "0x00634a0c856ec1db",
@@ -138,24 +154,28 @@ const vechain: CurrenciesData<Transaction> = {
               clauses: [
                 {
                   to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-                  value: "20000000000000000000",
+                  value: (2e19).toString(), // 20 VET
                   data: "0x",
                 },
               ],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
           }),
-          expectedStatus: {
-            amount: new BigNumber("20000000000000000000"),
-            errors: {
-              amount: new NotEnoughBalance(),
-            },
-            warnings: {},
-            totalSpent: new BigNumber("20000000000000000000"),
-            estimatedFees: new BigNumber("210000000000000000"),
+          expectedStatus: (_account, _, status): Partial<TransactionStatusCommon> => {
+            const estimatedFees = status.estimatedFees;
+            return {
+              amount: new BigNumber(2e19), // 20 VET
+              errors: {
+                amount: new NotEnoughBalance(),
+              },
+              warnings: {},
+              totalSpent: new BigNumber(2e19),
+              estimatedFees, // fees are calculated during preparation and therefore cannot be guessed without mocks
+            };
           },
         },
         {
@@ -166,7 +186,7 @@ const vechain: CurrenciesData<Transaction> = {
               "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
             estimatedFees: "515820000000000000",
             recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-            amount: "20000000000000000000",
+            amount: (2e19).toString(), // 20 VTHO
             body: {
               chainTag: MAINNET_CHAIN_TAG,
               blockRef: "0x00634a0c856ec1db",
@@ -174,24 +194,28 @@ const vechain: CurrenciesData<Transaction> = {
               clauses: [
                 {
                   to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-                  value: "20000000000000000000",
+                  value: (2e19).toString(), // 20 VTHO
                   data: "0x",
                 },
               ],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
           }),
-          expectedStatus: {
-            amount: new BigNumber("20000000000000000000"),
-            errors: {
-              amount: new NotEnoughBalance(),
-            },
-            warnings: {},
-            totalSpent: new BigNumber("20515820000000000000"),
-            estimatedFees: new BigNumber("515820000000000000"),
+          expectedStatus: (_account, _, status): Partial<TransactionStatusCommon> => {
+            const estimatedFees = status.estimatedFees;
+            return {
+              amount: new BigNumber(2e19), // 20 VTHO
+              errors: {
+                amount: new NotEnoughBalance(),
+              },
+              warnings: {},
+              totalSpent: new BigNumber(2e19).plus(estimatedFees),
+              estimatedFees, // fees are calculated during preparation and therefore cannot be guessed without mocks
+            };
           },
         },
       ],
@@ -211,7 +235,7 @@ const vechain: CurrenciesData<Transaction> = {
             family: "vechain",
             estimatedFees: "210000000000000000",
             recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-            amount: "1000000000000000000",
+            amount: (1e18).toString(), // 1 VET
             body: {
               chainTag: MAINNET_CHAIN_TAG,
               blockRef: "0x00634a0c856ec1db",
@@ -219,24 +243,28 @@ const vechain: CurrenciesData<Transaction> = {
               clauses: [
                 {
                   to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
-                  value: "1000000000000000000",
+                  value: (1e18).toString(),
                   data: "0x",
                 },
               ],
-              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
               gas: "0",
+              maxFeePerGas: 0,
+              maxPriorityFeePerGas: 0,
               dependsOn: null,
               nonce: generateNonce(),
             },
           }),
-          expectedStatus: {
-            amount: new BigNumber("1000000000000000000"),
-            estimatedFees: new BigNumber("210000000000000000"),
-            totalSpent: new BigNumber("1000000000000000000"),
-            errors: {
-              amount: new NotEnoughVTHO(),
-            },
-            warnings: {},
+          expectedStatus: (_account, _, status): Partial<TransactionStatusCommon> => {
+            const estimatedFees = status.estimatedFees;
+            return {
+              amount: new BigNumber(1e18), // 1 VET
+              estimatedFees, // fees are calculated during preparation and therefore cannot be guessed without mocks
+              totalSpent: new BigNumber(1e18),
+              errors: {
+                amount: new NotEnoughVTHO(),
+              },
+              warnings: {},
+            };
           },
         },
       ],

package/src/test/cli.ts

@@ -1,9 +1,8 @@
 import flatMap from "lodash/flatMap";
 import { Transaction, Transaction as VechainTransaction } from "../types";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
-import { VTHO_ADDRESS } from "../contracts/constants";
-import VIP180 from "../contracts/abis/VIP180";
 import { MustBeVechain } from "../errors";
+import { ABIContract, VIP180_ABI, VTHO_ADDRESS } from "@vechain/sdk-core";
 
 type CliTools = {
   options: Array<{
@@ -63,7 +62,9 @@ function inferTransactions(
       clauses.push({
         value: 0,
         to: VTHO_ADDRESS,
-        data: VIP180.transfer.encode(transaction.recipient, transaction.amount.toFixed()),
+        data: ABIContract.ofAbi(VIP180_ABI)
+          .encodeFunctionInput("transfer", [transaction.recipient, transaction.amount.toFixed()])
+          .toString(),
       });
     } else {
       throw new MustBeVechain();