@ledgerhq/coin-vechain 2.2.0-next.0

package/src/signer/signMessage.ts

@@ -0,0 +1,22 @@
+import { Transaction as ThorTransaction } from "thor-devkit";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { VechainSigner } from "../types";
+
+export const signMessage =
+  (signerContext: SignerContext<VechainSigner>) =>
+  async (deviceId: string, path: string, message: string, rawMessage: string) => {
+    let messageObj;
+    let unsigned: ThorTransaction;
+    try {
+      if (message) messageObj = JSON.parse(message);
+      else messageObj = JSON.parse(rawMessage);
+      unsigned = new ThorTransaction(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")),
+    );
+
+    return result.toString("hex");
+  };

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,24 @@
+import { SpeculosButton, deviceActionFlow } from "@ledgerhq/coin-framework/bot/specs";
+import type { Transaction } from "../types";
+import { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+
+const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+    },
+    { title: "Address", button: SpeculosButton.RIGHT },
+    { title: "Max Fees", button: SpeculosButton.RIGHT },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});
+
+export default { acceptTransaction };

package/src/test/bot-specs.ts

@@ -0,0 +1,210 @@
+import BigNumber from "bignumber.js";
+import invariant from "invariant";
+import type {
+  AppSpec,
+  TransactionArg,
+  TransactionRes,
+  TransactionTestInput,
+  SpeculosTransport,
+} from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types";
+import { pickSiblings, botTest, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import speculosDeviceActions from "./bot-deviceActions";
+
+const MIN_VET_TRANSACTION_AMOUNT = 1000000000000000000;
+const MAX_VTHO_FEE_FOR_VTHO_TRANSACTION = 1040000000000000000;
+const MAX_VTHO_FEE_FOR_VET_TRANSACTION = 420000000000000000;
+
+const vechainTest = {
+  currency: getCryptoCurrencyById("vechain"),
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "VeChain",
+    appVersion: "1.1.1",
+  },
+  allowEmptyAccounts: true,
+  testTimeout: 60 * 1000, // 1 minute
+  genericDeviceAction: speculosDeviceActions.acceptTransaction,
+  onSpeculosDeviceCreated: async ({ transport }: { transport: SpeculosTransport }) => {
+    // enable contract data
+    await transport.button(SpeculosButton.RIGHT);
+    await transport.button(SpeculosButton.BOTH);
+    await transport.button(SpeculosButton.BOTH);
+    await transport.button(SpeculosButton.RIGHT);
+    await transport.button(SpeculosButton.BOTH);
+    // enable multi-clause
+    await transport.button(SpeculosButton.RIGHT);
+    await transport.button(SpeculosButton.BOTH);
+    await transport.button(SpeculosButton.RIGHT);
+    await transport.button(SpeculosButton.BOTH);
+    await transport.button(SpeculosButton.RIGHT);
+    await transport.button(SpeculosButton.BOTH);
+  },
+};
+
+const vet: AppSpec<Transaction> = {
+  name: "VeChain VET",
+  ...vechainTest,
+  mutations: [
+    {
+      name: "move ~50% VET",
+      maxRun: 1,
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+        maxSpendable,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
+        if (!account.subAccounts?.[0]) throw new Error("no VTHO account");
+        invariant(account.balance.gt(MIN_VET_TRANSACTION_AMOUNT), "Vechain: VET balance is empty");
+        invariant(
+          account.subAccounts[0].balance.gt(MAX_VTHO_FEE_FOR_VET_TRANSACTION),
+          "Vechain: VTHO balance is not enough",
+        );
+        const sibling = pickSiblings(siblings, 2);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+        const amount = maxSpendable.div(2).integerValue();
+        const updates = [{ amount }, { recipient }];
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({
+        account,
+        accountBeforeTransaction,
+        operation,
+      }: TransactionTestInput<Transaction>): void | undefined => {
+        botTest("account balance decreased with operation value", () =>
+          expect(account.balance.toString()).toBe(
+            accountBeforeTransaction.balance.minus(operation.value).toString(),
+          ),
+        );
+      },
+    },
+    {
+      name: "move all VET",
+      maxRun: 1,
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
+        if (!account.subAccounts?.[0]) throw new Error("no VTHO account");
+        invariant(account.balance.gt(MIN_VET_TRANSACTION_AMOUNT), "Vechain: VET balance is empty");
+        invariant(
+          account.subAccounts?.[0].balance.gt(MAX_VTHO_FEE_FOR_VET_TRANSACTION),
+          "Vechain: VTHO balance is not enough",
+        );
+        const sibling = pickSiblings(siblings, 4);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+        const updates = [{ useAllAmount: true }, { recipient }];
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account }: TransactionTestInput<Transaction>): void | undefined => {
+        botTest("account balance decreased with operation value", () =>
+          expect(account.balance.toString()).toBe(new BigNumber(0).toString()),
+        );
+      },
+    },
+  ],
+};
+
+const vtho: AppSpec<Transaction> = {
+  name: "VeChain VTHO",
+  ...vechainTest,
+  skipOperationHistory: true,
+  mutations: [
+    {
+      name: "move ~50% VTHO",
+      maxRun: 1,
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
+        if (!account.subAccounts?.[0]) throw new Error("no VTHO account");
+        invariant(
+          account.subAccounts?.[0].balance.gt(MAX_VTHO_FEE_FOR_VTHO_TRANSACTION * 2),
+          "Vechain: VTHO balance is not enough",
+        );
+        const sibling = pickSiblings(siblings, 2);
+        const recipient = sibling.freshAddress;
+        if (
+          !account.subAccounts ||
+          !account.subAccounts[0] ||
+          !(account.subAccounts[0].type == "TokenAccount")
+        )
+          throw new Error("no VTHO account");
+        const tokenAccount = account.subAccounts[0];
+        const transaction = bridge.createTransaction(tokenAccount);
+        const amount = tokenAccount.balance.div(2).integerValue();
+        const updates = [{ amount }, { recipient }, { subAccountId: tokenAccount.id }];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({
+        account,
+        accountBeforeTransaction,
+      }: TransactionTestInput<Transaction>): void | undefined => {
+        botTest("account balance decreased with operation value", () =>
+          expect(account?.subAccounts?.[0].balance.toString()).toBe(
+            new BigNumber(accountBeforeTransaction?.subAccounts?.[0].balance || 0)
+              .div(2)
+              .toString(),
+          ),
+        );
+      },
+    },
+    {
+      name: "move all VTHO",
+      maxRun: 1,
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
+        if (!account.subAccounts?.[0]) throw new Error("no VTHO account");
+        invariant(
+          account.subAccounts?.[0].balance.gt(MAX_VTHO_FEE_FOR_VTHO_TRANSACTION),
+          "Vechain: VTHO balance is not enough",
+        );
+        const sibling = pickSiblings(siblings, 4);
+        const recipient = sibling.freshAddress;
+        if (
+          !account.subAccounts ||
+          !account.subAccounts[0] ||
+          !(account.subAccounts[0].type == "TokenAccount")
+        )
+          throw new Error("no VTHO account");
+        const transaction = bridge.createTransaction(account);
+        const updates = [
+          { useAllAmount: true },
+          { recipient },
+          { subAccountId: account.subAccounts[0].id },
+        ];
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account }: TransactionTestInput<Transaction>): void | undefined => {
+        botTest("account balance decreased with operation value", () =>
+          expect(account?.subAccounts?.[0].balance.toString()).toBe(new BigNumber(0).toString()),
+        );
+      },
+    },
+  ],
+};
+
+export default { vtho, vet };

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,262 @@
+import BigNumber from "bignumber.js";
+import type { AccountRaw, CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+import { fromTransactionRaw } from "../bridge/transaction";
+import { DEFAULT_GAS_COEFFICIENT, 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 {
+  listSupportedCurrencies,
+  setSupportedCurrencies,
+} from "@ledgerhq/coin-framework/currencies/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+const listSupported = listSupportedCurrencies();
+listSupported.push(getCryptoCurrencyById("vechain"));
+setSupportedCurrencies(listSupported.map(c => c.id) as CryptoCurrencyId[]);
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const vechain: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: ["balance", "spendableBalance", "estimateMaxSpendable"], // the balance depends on VTHO and it's earned without operations
+  scanAccounts: vechainScanAccounts1,
+
+  accounts: [
+    {
+      raw: vechain1 as AccountRaw,
+      transactions: [
+        {
+          name: "Send VET",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            estimatedFees: "210000000000000000",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "1000000000000000000",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [
+                {
+                  to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                  value: "1000000000000000000",
+                  data: "0x",
+                },
+              ],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1000000000000000000"),
+            estimatedFees: new BigNumber("210000000000000000"),
+            totalSpent: new BigNumber("1000000000000000000"),
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "Send VTHO",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            subAccountId:
+              "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
+            estimatedFees: "515180000000000000",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "1000000000000000000",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [
+                {
+                  to: "0x0000000000000000000000000000456e65726779",
+                  value: 0,
+                  data: VIP180.transfer.encode(
+                    "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                    "9000000000000000000",
+                  ),
+                },
+              ],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1000000000000000000"),
+            estimatedFees: new BigNumber("515180000000000000"),
+            totalSpent: new BigNumber("1515180000000000000"),
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "Amount required",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            estimatedFees: "0",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [{ to: "", value: 0, data: "0x" }],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "VET balance not enough",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            estimatedFees: "210000000000000000",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "20000000000000000000",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [
+                {
+                  to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                  value: "20000000000000000000",
+                  data: "0x",
+                },
+              ],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("20000000000000000000"),
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+            totalSpent: new BigNumber("20000000000000000000"),
+            estimatedFees: new BigNumber("210000000000000000"),
+          },
+        },
+        {
+          name: "VTHO balance not enough",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            subAccountId:
+              "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
+            estimatedFees: "515820000000000000",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "20000000000000000000",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [
+                {
+                  to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                  value: "20000000000000000000",
+                  data: "0x",
+                },
+              ],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("20000000000000000000"),
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+            totalSpent: new BigNumber("20515820000000000000"),
+            estimatedFees: new BigNumber("515820000000000000"),
+          },
+        },
+      ],
+      FIXME_tests: [
+        "balance is sum of ops", // the balance depends on VTHO and it's earned without operations
+        "empty transaction is equals to itself", //nonce is not deterministic
+        "ref stability on self transaction", //blockref is not deterministic
+        "can be run in parallel and all yield same results", //blockref is not deterministic
+      ],
+    },
+    {
+      raw: vechain3 as AccountRaw,
+      transactions: [
+        {
+          name: "Not enough VTHO to pay fees",
+          transaction: fromTransactionRaw({
+            family: "vechain",
+            estimatedFees: "210000000000000000",
+            recipient: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+            amount: "1000000000000000000",
+            body: {
+              chainTag: MAINNET_CHAIN_TAG,
+              blockRef: "0x00634a0c856ec1db",
+              expiration: 18,
+              clauses: [
+                {
+                  to: "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
+                  value: "1000000000000000000",
+                  data: "0x",
+                },
+              ],
+              gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+              gas: "0",
+              dependsOn: null,
+              nonce: generateNonce(),
+            },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1000000000000000000"),
+            estimatedFees: new BigNumber("210000000000000000"),
+            totalSpent: new BigNumber("1000000000000000000"),
+            errors: {
+              amount: new NotEnoughVTHO(),
+            },
+            warnings: {},
+          },
+        },
+      ],
+      FIXME_tests: [
+        "balance is sum of ops", // the balance depends on VTHO and it's earned without operations
+        "empty transaction is equals to itself", //nonce is not deterministic
+        "ref stability on self transaction", //blockref is not deterministic
+        "can be run in parallel and all yield same results", //blockref is not deterministic
+      ],
+    },
+  ],
+};
+
+// describe("VeChain Bridge", () => {
+//   test.todo("sample test");
+// });
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js", "mock"],
+  currencies: {
+    vechain,
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,86 @@
+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";
+
+type CliTools = {
+  options: Array<{
+    name: string;
+    type: any;
+    desc: string;
+  }>;
+  inferTransactions: (
+    transactions: Array<{
+      account: AccountLike;
+      transaction: Transaction;
+      mainAccount: Account;
+    }>,
+    opts: Record<string, any>,
+  ) => Transaction[];
+};
+
+type Clauses = {
+  to: string;
+  data: string;
+  value: string | number;
+};
+
+const options = [
+  {
+    name: "vechainCurrency",
+    type: String,
+    desc: 'select between sending VET or VTHO using "VET" or "VTHO" strings',
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    let subAccountId =
+      account.type == "Account" && account.subAccounts ? account.subAccounts[0].id : "";
+
+    if (account.type === "TokenAccount") {
+      subAccountId = account.id;
+    }
+
+    const clauses: Array<Clauses> = [];
+
+    if (opts.vechainCurrency == "VET") {
+      clauses.push({
+        to: transaction.recipient,
+        value: "0x" + transaction.amount.toString(16),
+        data: "0x",
+      });
+    } else if (opts.vechainCurrency == "VTHO") {
+      clauses.push({
+        value: 0,
+        to: VTHO_ADDRESS,
+        data: VIP180.transfer.encode(transaction.recipient, transaction.amount.toFixed()),
+      });
+    } else {
+      throw new MustBeVechain();
+    }
+
+    return {
+      ...transaction,
+      family: "vechain",
+      subAccountId: opts.vechainCurrency == "VTHO" ? subAccountId : "",
+      body: { ...(transaction as VechainTransaction).body, clauses },
+    } as VechainTransaction;
+  });
+}
+
+export default function makeCliTools(): CliTools {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,6 @@
+import makeCliTools from "./cli";
+
+export * from "./bridgeDatasetTest";
+export { makeCliTools };
+export * from "./bot-deviceActions";
+export * from "./bot-specs";

package/src/types/bridge.ts

@@ -0,0 +1,35 @@
+import type {
+  TokenAccount,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { Transaction as ThorTransaction } from "thor-devkit";
+
+export type Transaction = TransactionCommon & {
+  family: "vechain";
+  estimatedFees: string;
+  body: ThorTransaction.Body;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "vechain";
+  estimatedFees: string;
+  body: ThorTransaction.Body;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type TransactionInfo = {
+  isTokenAccount: boolean;
+  amount: BigNumber;
+  balance: BigNumber;
+  spendableBalance: BigNumber;
+  tokenAccount: TokenAccount | undefined;
+  estimatedFees: string;
+  estimatedGas: number;
+};

package/src/types/constants.ts

@@ -0,0 +1,5 @@
+export const MAINNET_CHAIN_TAG = 74;
+export const TESTNET_CHAIN_TAG = 39;
+export const DEFAULT_GAS_COEFFICIENT = 0;
+export const HEX_PREFIX = "0x";
+export const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./bridge";
+export * from "./signer";
+export * from "./constants";
+export * from "./network";