@ledgerhq/coin-vechain 2.2.0-next.0

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,41 @@
+import { Account } from "@ledgerhq/types-live";
+import { Transaction as VeChainThorTransaction } from "thor-devkit";
+import {
+  calculateTransactionInfo,
+  isValid,
+  calculateClausesVet,
+  calculateClausesVtho,
+} from "../common-logic";
+import { Transaction } from "../types";
+import { getBlockRef } from "../network";
+
+/**
+ * Prepare transaction before checking status
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ */
+export const prepareTransaction = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<Transaction> => {
+  const { amount, isTokenAccount, estimatedFees, estimatedGas } = await calculateTransactionInfo(
+    account,
+    transaction,
+  );
+
+  let blockRef = "";
+
+  let clauses: Array<VeChainThorTransaction.Clause> = [];
+  if (transaction.recipient && isValid(transaction.recipient)) {
+    blockRef = await getBlockRef();
+    if (isTokenAccount) {
+      clauses = await calculateClausesVtho(transaction.recipient, amount);
+    } else {
+      clauses = await calculateClausesVet(transaction.recipient, amount);
+    }
+  }
+
+  const body = { ...transaction.body, gas: estimatedGas, blockRef, clauses };
+  return { ...transaction, body, amount, estimatedFees };
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,53 @@
+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";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (signerContext: SignerContext<VechainSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: Transaction;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+      async function main() {
+        const unsigned = new ThorTransaction(transaction.body);
+
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        const signature = await signerContext(deviceId, signer =>
+          signer.signTransaction(account.freshAddressPath, unsigned.encode().toString("hex")),
+        );
+
+        o.next({ type: "device-signature-granted" });
+
+        const operation = await buildOptimisticOperation(account, transaction);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signature.toString("hex"),
+            rawData: transaction,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/synchronisation.ts

@@ -0,0 +1,86 @@
+import { BigNumber } from "bignumber.js";
+
+import eip55 from "eip55";
+import {
+  emptyHistoryCache,
+  encodeAccountId,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+
+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";
+
+export const getAccountShape: GetAccountShape<Account> = async info => {
+  const { initialAccount, currency, derivationMode } = info;
+  const address = eip55.encode(info.address);
+
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 1;
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  // get the current account balance state depending your api implementation
+  const { balance, energy } = await getAccount(address);
+
+  // get the current block height
+  const blockHeight = await getLastBlockHeight();
+
+  // Merge new operations with the previously synced ones
+  const newOperations = await getOperations(accountId, address, startAt);
+
+  //Get last token operations
+  const vthoAccountId = encodeTokenAccountId(accountId, findTokenById("vechain/vip180/vtho")!);
+  const vthoOperations = await getTokenOperations(vthoAccountId, address, VTHO_ADDRESS, 1); // from parameter must be 1 otherwise the response is empty
+
+  const operations = mergeOps(oldOperations, newOperations);
+
+  //Account creation date set to now if there are no operation or at the first operation on the account
+  let minDate = -1;
+  if (operations.length != 0) {
+    const operationsDates = operations.map(c => c.date.getTime());
+    operationsDates.concat(vthoOperations.map(c => c.date.getTime()));
+    minDate = Math.min(...operationsDates);
+  }
+
+  const shape = {
+    id: accountId,
+    balance: new BigNumber(balance),
+    creationDate: minDate != -1 ? new Date(minDate) : new Date(),
+    spendableBalance: new BigNumber(balance),
+    operationsCount: operations.length,
+    operations,
+    blockHeight,
+    feesCurrency: getTokenById("vechain/vip180/vtho"),
+    subAccounts: [
+      {
+        type: "TokenAccount" as const,
+        id: vthoAccountId,
+        parentId: accountId,
+        token: getTokenById("vechain/vip180/vtho"),
+        balance: new BigNumber(energy),
+        spendableBalance: new BigNumber(energy),
+        creationDate: minDate != -1 ? new Date(minDate) : new Date(),
+        operationsCount: vthoOperations.length,
+        operations: vthoOperations,
+        blockHeight,
+        pendingOperations:
+          (initialAccount?.subAccounts && initialAccount.subAccounts[0]?.pendingOperations) || [],
+        balanceHistoryCache:
+          (initialAccount?.subAccounts && initialAccount.subAccounts[0]?.balanceHistoryCache) ||
+          emptyHistoryCache,
+        swapHistory: [],
+      },
+    ],
+  };
+
+  return shape;
+};

package/src/bridge/transaction.ts

@@ -0,0 +1,79 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import type {
+  Transaction,
+  TransactionRaw,
+  TransactionStatus,
+  TransactionStatusRaw,
+} from "../types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+
+export const formatTransaction = (t: Transaction, account: Account): string => {
+  const { amount, recipient, useAllAmount } = t;
+  let displayedAmount: string;
+  if (useAllAmount) {
+    displayedAmount = "MAX";
+  } else if (amount.isZero()) {
+    displayedAmount = "";
+  } else {
+    displayedAmount =
+      " " +
+      formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+        showCode: true,
+        disableRounding: true,
+      });
+  }
+  return `SEND ${displayedAmount} TO ${recipient}`;
+};
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+
+  return {
+    ...tr,
+    ...common,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...t,
+    ...common,
+  };
+};
+
+export const fromTransactionStatusRaw = (ts: TransactionStatusRaw): TransactionStatus => {
+  const common = fromTransactionStatusRawCommon(ts);
+
+  return {
+    ...ts,
+    ...common,
+  };
+};
+
+export const toTransactionStatusRaw = (ts: TransactionStatus): TransactionStatusRaw => {
+  const common = toTransactionStatusRawCommon(ts);
+
+  return {
+    ...ts,
+    ...common,
+  };
+};
+
+export default {
+  formatTransaction,
+  formatTransactionStatus,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+};

package/src/common-logic/address-utils.ts

@@ -0,0 +1,11 @@
+import { address } from "thor-devkit";
+import hexUtils from "./hex-utils";
+
+export const isValid = (addr: string): boolean => {
+  try {
+    address.toChecksumed(hexUtils.addPrefix(addr));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};

package/src/common-logic/hex-utils.ts

@@ -0,0 +1,53 @@
+const PREFIX = "0x";
+const PREFIX_REGEX = /^0[xX]/;
+const HEX_REGEX = /^(0[xX])?[a-fA-F0-9]+$/;
+
+/**
+ * Returns the provied hex string with the hex prefix removed.
+ * If the prefix doesn't exist the hex is returned unmodified
+ * @param hex - the input hex string
+ * @returns the input hex string with the hex prefix removed
+ * @throws an error if the input is not a valid hex string
+ */
+const removePrefix = (hex: string): string => {
+  validate(hex);
+  return hex.replace(PREFIX_REGEX, "");
+};
+
+/**
+ * Returns the provided hex string with the hex prefix added.
+ * If the prefix already exists the string is returned unmodified.
+ * If the string contains an UPPER case `X` in the prefix it will be replaced with a lower case `x`
+ * @param hex - the input hex string
+ * @returns the input hex string with the hex prefix added
+ * @throws an error if the input is not a valid hex string
+ */
+const addPrefix = (hex: string): string => {
+  validate(hex);
+  return PREFIX_REGEX.test(hex) ? hex.replace(PREFIX_REGEX, PREFIX) : `${PREFIX}${hex}`;
+};
+
+/**
+ * Validate the hex string. Throws an Error if not valid
+ * @param hex - the input hex string
+ * @throws an error if the input is not a valid hex string
+ */
+const validate = (hex: string) => {
+  if (!isValid(hex)) throw Error(`Provided hex value is not valid ${hex}`);
+};
+
+/**
+ * Check if input string is valid
+ * @param hex - the input hex string
+ * @returns boolean representing whether the input hex is valid
+ */
+const isValid = (hex: string): boolean => {
+  return HEX_REGEX.test(hex);
+};
+
+export default {
+  removePrefix,
+  addPrefix,
+  validate,
+  isValid,
+};

package/src/common-logic/index.ts

@@ -0,0 +1,6 @@
+export * from "./address-utils";
+export * from "./hex-utils";
+export * from "./logic";
+export * from "./mapping-utils";
+export * from "./pad-address";
+export * from "./transaction-utils";

package/src/common-logic/logic.ts

@@ -0,0 +1,44 @@
+import BigNumber from "bignumber.js";
+import { Transaction as VeChainThorTransaction } from "thor-devkit";
+import { VTHO_ADDRESS } from "../contracts/constants";
+import VIP180 from "../contracts/abis/VIP180";
+import { HEX_PREFIX } from "../types";
+
+export const calculateClausesVtho = async (
+  recipient: string,
+  amount: BigNumber,
+): Promise<VeChainThorTransaction.Clause[]> => {
+  const clauses: VeChainThorTransaction.Clause[] = [];
+
+  // Get the existing clause or create a blank one
+  const updatedClause: VeChainThorTransaction.Clause = {
+    to: VTHO_ADDRESS,
+    value: 0,
+    data: "0x",
+  };
+  updatedClause.data = VIP180.transfer.encode(recipient, amount.toFixed());
+
+  clauses.push(updatedClause);
+  return clauses;
+};
+
+export const calculateClausesVet = async (
+  recipient: string,
+  amount: BigNumber,
+): Promise<VeChainThorTransaction.Clause[]> => {
+  const clauses: VeChainThorTransaction.Clause[] = [];
+
+  // Get the existing clause or create a blank one
+  const updatedClause: VeChainThorTransaction.Clause = {
+    to: null,
+    value: 0,
+    data: "0x",
+  };
+
+  updatedClause.value = `${HEX_PREFIX}${amount.toString(16)}`;
+  updatedClause.to = recipient;
+
+  clauses.push(updatedClause);
+
+  return clauses;
+};

package/src/common-logic/mapping-utils.ts

@@ -0,0 +1,67 @@
+import BigNumber from "bignumber.js";
+import vip180 from "../contracts/abis/VIP180";
+import { Operation } from "@ledgerhq/types-live";
+import { EventLog, TransferLog } from "../types";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getFees } from "../network";
+
+export const mapVetTransfersToOperations = async (
+  txs: TransferLog[],
+  accountId: string,
+  addr: string,
+): Promise<Operation[]> => {
+  return Promise.all(
+    txs.map(async tx => {
+      const fees = await getFees(tx.meta.txID);
+      return {
+        id: encodeOperationId(
+          accountId,
+          tx.meta.txID,
+          tx.recipient === addr.toLowerCase() ? "IN" : "OUT",
+        ),
+        hash: tx.meta.txID,
+        type: tx.recipient === addr.toLowerCase() ? "IN" : "OUT",
+        value: new BigNumber(tx.amount),
+        fee: new BigNumber(fees),
+        senders: [tx.sender],
+        recipients: [tx.recipient],
+        blockHeight: tx.meta.blockNumber,
+        blockHash: tx.meta.blockID,
+        accountId,
+        date: new Date(tx.meta.blockTimestamp * 1000),
+        extra: {},
+      };
+    }),
+  );
+};
+
+export const mapTokenTransfersToOperations = async (
+  evnts: EventLog[],
+  accountId: string,
+  addr: string,
+): Promise<Operation[]> => {
+  return Promise.all(
+    evnts.map(async evnt => {
+      const decoded = vip180.TransferEvent.decode(evnt.data, evnt.topics);
+      const fees = await getFees(evnt.meta.txID);
+      return {
+        id: encodeOperationId(
+          accountId,
+          evnt.meta.txID,
+          decoded.to === addr.toLowerCase() ? "IN" : "OUT",
+        ),
+        hash: evnt.meta.txID,
+        type: decoded.to === addr.toLowerCase() ? "IN" : "OUT",
+        value: new BigNumber(decoded.value),
+        fee: fees,
+        senders: [decoded.from],
+        recipients: [decoded.to],
+        blockHeight: evnt.meta.blockNumber,
+        blockHash: evnt.meta.blockID,
+        accountId,
+        date: new Date(evnt.meta.blockTimestamp * 1000),
+        extra: {},
+      };
+    }),
+  );
+};

package/src/common-logic/pad-address.ts

@@ -0,0 +1,8 @@
+export const padAddress = (address: string): string => {
+  const splittedAddr = address.split("x");
+  const hexMiss = 64 - splittedAddr[1].length;
+  for (let i = 0; i < hexMiss; i++) {
+    splittedAddr[1] = `0${splittedAddr[1]}`;
+  }
+  return splittedAddr.join("x");
+};

package/src/common-logic/transaction-utils.ts

@@ -0,0 +1,190 @@
+import BigNumber from "bignumber.js";
+import { DEFAULT_GAS_COEFFICIENT, HEX_PREFIX } from "../types";
+import crypto from "crypto";
+import { Transaction as ThorTransaction } from "thor-devkit";
+import params from "../contracts/abis/params";
+import { BASE_GAS_PRICE_KEY, PARAMS_ADDRESS } from "../contracts/constants";
+import { query } from "../network";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import { Transaction, TransactionInfo, Query } from "../types";
+import { isValid } from "./address-utils";
+import { calculateClausesVet, calculateClausesVtho } from "./logic";
+import { ImpossibleToCalculateAmountAndFees } from "../errors";
+
+const GAS_COEFFICIENT = 15000;
+
+/**
+ * Generate a Unique ID to be used as a nonce
+ * @returns a unique string
+ */
+export const generateNonce = (): string => {
+  const randBuffer = crypto.randomBytes(Math.ceil(4));
+  if (!randBuffer) throw Error("Failed to generate random hex");
+  return `${HEX_PREFIX}${randBuffer.toString("hex").substring(0, 8)}`;
+};
+
+/**
+ * Estimate the gas that will be used by the transaction.
+ * @param transaction - The transaction to estimate the gas for
+ * @returns an estimate of the gas usage
+ */
+export const estimateGas = async (t: Transaction): Promise<number> => {
+  const intrinsicGas = ThorTransaction.intrinsicGas(t.body.clauses);
+
+  const queryData: Query[] = [];
+
+  t.body.clauses.forEach(c => {
+    if (c.to) {
+      queryData.push({
+        to: c.to,
+        data: c.data,
+      });
+    }
+  });
+
+  const response = await query(queryData);
+
+  const execGas = response.reduce((sum, out) => sum + out.gasUsed, 0);
+
+  return intrinsicGas + (execGas ? execGas + GAS_COEFFICIENT : 0);
+};
+
+const getBaseGasPrice = async (): Promise<string> => {
+  const queryData: Query = {
+    to: PARAMS_ADDRESS,
+    data: params.get.encode(BASE_GAS_PRICE_KEY),
+  };
+
+  const response = await query([queryData]);
+
+  // Expect 1 value
+  if (response && response.length != 1) throw Error("Unexpected response received for query");
+
+  return response[0].data;
+};
+
+/**
+ * Calculate the fee in VTHO
+ * @param gas - the gas used
+ * @param gasPriceCoef - the gas price coefficient
+ * @returns the fee in VTHO
+ */
+export const calculateFee = async (gas: BigNumber, gasPriceCoef: number): Promise<BigNumber> => {
+  const baseGasPrice = await getBaseGasPrice();
+  return new BigNumber(baseGasPrice).times(gasPriceCoef).idiv(255).plus(baseGasPrice).times(gas);
+};
+
+// Here there is a circular dependency between values, that is why we need the do-while loop
+// dependencies are:
+// useAllAmount: USER
+// amount: useAllAmount & spendableBalance
+// fees: amount
+// spendableBalance: fees & balance
+// balance: USER
+// circular dependency is:
+// amount -> spendableBalance -> fees -> amount
+
+export const calculateTransactionInfo = async (
+  account: Account,
+  transaction: Transaction,
+  fixedMaxTokenFees?: {
+    estimatedGas: number;
+    estimatedGasFees: BigNumber;
+  },
+): Promise<TransactionInfo> => {
+  const { subAccounts } = account;
+  const { amount: oldAmount, subAccountId, useAllAmount } = transaction;
+
+  const tokenAccount =
+    subAccountId && subAccounts
+      ? (subAccounts.find(subAccount => {
+          return subAccount.id === subAccountId;
+        }) as TokenAccount)
+      : undefined;
+  const isTokenAccount = !!tokenAccount;
+
+  let amount = oldAmount;
+  let amountBackup;
+  let tempTransaction = { ...transaction, amount };
+  let balance = account.balance;
+  let spendableBalance = account.balance;
+  let maxEstimatedGasFees = new BigNumber(0);
+  let maxEstimatedGas = 0;
+
+  if (!amount.isNaN()) {
+    const MAX_ITERATIONS = 5; // it should never reach more than 2 iterations, but just in case
+    let iterations = 0;
+    do {
+      amountBackup = amount;
+
+      const estimatedGasAndFees =
+        fixedMaxTokenFees || (await calculateGasFees(tempTransaction, isTokenAccount));
+
+      maxEstimatedGasFees = estimatedGasAndFees.estimatedGasFees;
+      maxEstimatedGas = estimatedGasAndFees.estimatedGas;
+
+      if (isTokenAccount && tokenAccount) {
+        balance = tokenAccount.balance;
+        spendableBalance = tokenAccount.balance.minus(maxEstimatedGasFees).gt(0)
+          ? tokenAccount.balance.minus(maxEstimatedGasFees)
+          : new BigNumber(0);
+      } else {
+        balance = account.balance;
+        spendableBalance = account.balance;
+      }
+
+      amount = useAllAmount ? spendableBalance : oldAmount;
+
+      tempTransaction = {
+        ...tempTransaction,
+        amount,
+      };
+      iterations++;
+    } while (!amountBackup.isEqualTo(amount) && iterations < MAX_ITERATIONS);
+    if (iterations === MAX_ITERATIONS) {
+      throw new ImpossibleToCalculateAmountAndFees();
+    }
+  }
+
+  return {
+    isTokenAccount,
+    amount,
+    spendableBalance,
+    balance,
+    tokenAccount,
+    estimatedFees: maxEstimatedGasFees.toString(),
+    estimatedGas: maxEstimatedGas,
+  };
+};
+
+export const calculateGasFees = async (
+  transaction: Transaction,
+  isTokenAccount: boolean,
+): Promise<{
+  estimatedGas: number;
+  estimatedGasFees: BigNumber;
+}> => {
+  if (transaction.recipient && isValid(transaction.recipient)) {
+    let clauses;
+    if (isTokenAccount) {
+      clauses = await calculateClausesVtho(transaction.recipient, transaction.amount);
+    } else {
+      clauses = await calculateClausesVet(transaction.recipient, transaction.amount);
+    }
+    const gas = await estimateGas({
+      ...transaction,
+      body: { ...transaction.body, clauses: clauses },
+    });
+    return {
+      estimatedGas: gas,
+      estimatedGasFees: await calculateFee(
+        new BigNumber(gas),
+        transaction.body.gasPriceCoef || DEFAULT_GAS_COEFFICIENT,
+      ),
+    };
+  }
+  return {
+    estimatedGas: 0,
+    estimatedGasFees: new BigNumber(0),
+  };
+};

package/src/config.ts

@@ -0,0 +1,18 @@
+import { CurrencyConfig, CoinConfig } from "@ledgerhq/coin-framework/config";
+import { MissingCoinConfig } from "@ledgerhq/coin-framework/errors";
+
+export type VechainCoinConfig = () => CurrencyConfig;
+
+let coinConfig: CoinConfig<CurrencyConfig> | undefined;
+
+export function setCoinConfig(config: CoinConfig<CurrencyConfig>): void {
+  coinConfig = config;
+}
+
+export function getCoinConfig(): CurrencyConfig {
+  if (!coinConfig) {
+    throw new MissingCoinConfig();
+  }
+
+  return coinConfig();
+}