@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/vechain/broadcast.ts

@@ -0,0 +1,22 @@
+import { Transaction as VeChainThorTransaction } from "thor-devkit";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "../../operation";
+import { Transaction } from "./types";
+import { submit } from "./api";
+
+/**
+ * Broadcast the signed transaction
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation, rawData },
+}) => {
+  const transaction = new VeChainThorTransaction(
+    (rawData as unknown as VeChainThorTransaction).body,
+  );
+  transaction.signature = Buffer.from(signature, "hex");
+  const hash = await submit(transaction);
+
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/families/vechain/buildOptimisticOperatioin.ts

@@ -0,0 +1,46 @@
+import { Account, Operation } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import { encodeOperationId } from "../../operation";
+import BigNumber from "bignumber.js";
+
+export const buildOptimisticOperation = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<Operation> => {
+  const TYPE_OUT = "OUT";
+  const subAccountId = transaction.subAccountId;
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", TYPE_OUT),
+    hash: "",
+    type: subAccountId ? "NONE" : TYPE_OUT,
+    value: subAccountId ? new BigNumber(0) : new BigNumber(transaction.amount),
+    fee: subAccountId ? new BigNumber(0) : new BigNumber(transaction.estimatedFees),
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    date: new Date(),
+    extra: {},
+    subOperations: subAccountId
+      ? [
+          {
+            id: encodeOperationId(subAccountId, "", "OUT"),
+            hash: "",
+            type: "OUT",
+            value: transaction.amount,
+            fee: subAccountId ? new BigNumber(transaction.estimatedFees) : new BigNumber(0),
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient].filter(Boolean),
+            accountId: subAccountId,
+            date: new Date(),
+            extra: {},
+          },
+        ]
+      : [],
+  };
+
+  return operation;
+};

package/src/families/vechain/createTransaction.ts

@@ -0,0 +1,32 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { DEFAULT_GAS_COEFFICIENT, MAINNET_CHAIN_TAG } from "./constants";
+import { generateNonce } from "./utils/transaction-utils";
+import { Transaction } from "./types";
+
+/**
+ * Create an empty VET or VTHO transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  const chainTag = MAINNET_CHAIN_TAG;
+
+  return {
+    family: "vechain",
+    body: {
+      chainTag,
+      blockRef: "0x0000000000000000",
+      expiration: 18,
+      clauses: [],
+      gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
+      gas: "0",
+      dependsOn: null,
+      nonce: generateNonce(),
+    },
+    amount: new BigNumber(0),
+    estimatedFees: "0",
+    recipient: "",
+    useAllAmount: false,
+  };
+};

package/src/families/vechain/estimateMaxSpendable.ts

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { calculateGasFees } from "./utils/transaction-utils";
+import type { Transaction } from "./types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  transaction,
+}): Promise<BigNumber> => {
+  if (account.type === "Account" || !transaction) {
+    return account.balance;
+  }
+
+  const { estimatedGasFees: maxTokenFees } = await calculateGasFees(transaction, true);
+  const spendable = account.balance.minus(maxTokenFees);
+  if (spendable.gt(0)) return account.balance.minus(maxTokenFees);
+  return new BigNumber(0);
+};

package/src/families/vechain/getTransactionStatus.ts

@@ -0,0 +1,77 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { calculateTransactionInfo } from "./utils/transaction-utils";
+import { isValid } from "./utils/address-utils";
+import type { Transaction } from "./types";
+import { NotEnoughVTHO } from "./errors";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  const { freshAddress, currency, subAccounts } = account;
+  const { body, recipient, amount } = transaction;
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const { isTokenAccount, spendableBalance } = await calculateTransactionInfo(
+    account,
+    transaction,
+    {
+      estimatedGas: body.gas as number,
+      estimatedGasFees: new BigNumber(transaction.estimatedFees),
+    },
+  );
+
+  if (!body || !body.gas) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (freshAddress.toLowerCase() === recipient.toLowerCase()) {
+    warnings.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isValid(recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: currency.name,
+    });
+  }
+  const estimatedFees = new BigNumber(transaction.estimatedFees);
+  if (!amount.gt(0)) {
+    if (!transaction.useAllAmount) errors.amount = new AmountRequired();
+    else errors.amount = new NotEnoughBalance();
+  } else {
+    if (amount.gt(spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+    if (!isTokenAccount) {
+      // vet
+      const vthoBalance = subAccounts?.[0].balance;
+      if (estimatedFees.gt(vthoBalance || 0)) {
+        errors.amount = new NotEnoughVTHO();
+      }
+    }
+  }
+
+  let totalSpent = amount;
+  if (isTokenAccount) {
+    totalSpent = amount.plus(estimatedFees);
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+};
+
+export default getTransactionStatus;

package/src/families/vechain/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 "./constants";
+
+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/families/vechain/prepareTransaction.ts

@@ -0,0 +1,38 @@
+import { Account } from "@ledgerhq/types-live";
+import { Transaction as VeChainThorTransaction } from "thor-devkit";
+import { calculateTransactionInfo } from "./utils/transaction-utils";
+import { isValid } from "./utils/address-utils";
+import { Transaction } from "./types";
+import { getBlockRef } from "./api";
+import { calculateClausesVet, calculateClausesVtho } from "./logic";
+
+/**
+ * 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/families/vechain/signOperation.ts

@@ -0,0 +1,54 @@
+import { Observable } from "rxjs";
+import Vet from "@ledgerhq/hw-app-vet";
+import { Transaction as ThorTransaction } from "thor-devkit";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperatioin";
+import { withDevice } from "../../hw/deviceAccess";
+import type { Transaction } from "./types";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const signOperation: AccountBridge<Transaction>["signOperation"] = ({
+  account,
+  deviceId,
+  transaction,
+}) =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          const unsigned = new ThorTransaction(transaction.body);
+
+          // Sign on device
+          const vechainApp = new Vet(transport);
+          o.next({
+            type: "device-signature-requested",
+          });
+          const signature = await vechainApp.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),
+        );
+      }),
+  );
+
+export default signOperation;

package/src/families/vechain/utils/transaction-utils.ts

@@ -9,7 +9,7 @@ import { query } from "../api/sdk";
 import { Account, TokenAccount } from "@ledgerhq/types-live";
 import { Transaction, TransactionInfo } from "../types";
 import { isValid } from "./address-utils";
-import { calculateClausesVet, calculateClausesVtho } from "../js-transaction";
+import { calculateClausesVet, calculateClausesVtho } from "../logic";
 import { ImpossibleToCalculateAmountAndFees } from "../errors";
 
 const GAS_COEFFICIENT = 15000;

package/src/featureFlags/defaultFeatures.ts

@@ -71,7 +71,11 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyCasper: DEFAULT_FEATURE,
   currencyNeonEvm: DEFAULT_FEATURE,
   currencyLinea: DEFAULT_FEATURE,
-  currencyLineaTesnet: DEFAULT_FEATURE,
+  currencyLineaSepolia: DEFAULT_FEATURE,
+  currencyBlast: DEFAULT_FEATURE,
+  currencyBlastSepolia: DEFAULT_FEATURE,
+  currencyScroll: DEFAULT_FEATURE,
+  currencyScrollSepolia: DEFAULT_FEATURE,
 };
 
 /**
@@ -92,7 +96,6 @@ export const DEFAULT_FEATURES: Features = {
   disableNftLedgerMarket: DEFAULT_FEATURE,
   disableNftRaribleOpensea: DEFAULT_FEATURE,
   disableNftSend: DEFAULT_FEATURE,
-  staxWelcomeScreen: DEFAULT_FEATURE,
   listAppsV2minor1: DEFAULT_FEATURE,
   flexibleContentCards: DEFAULT_FEATURE,
   ethStakingProviders: initFeature(),
@@ -412,6 +415,8 @@ export const DEFAULT_FEATURES: Features = {
   },
 
   ptxSwapMoonpayProvider: DEFAULT_FEATURE,
+  ptxSwapExodusProvider: DEFAULT_FEATURE,
+  ptxSwapThorswapProvider: DEFAULT_FEATURE,
 
   llmAnalyticsOptInPrompt: {
     enabled: false,
@@ -455,7 +460,6 @@ export const DEFAULT_FEATURES: Features = {
 
   lldChatbotSupport: DEFAULT_FEATURE,
   llmChatbotSupport: DEFAULT_FEATURE,
-  supportDeviceStax: DEFAULT_FEATURE,
   supportDeviceEuropa: DEFAULT_FEATURE,
   lldRefreshMarketData: {
     ...DEFAULT_FEATURE,
@@ -463,8 +467,15 @@ export const DEFAULT_FEATURES: Features = {
       refreshTime: 3, //nb minutes
     },
   },
+  llmRefreshMarketData: {
+    ...DEFAULT_FEATURE,
+    params: {
+      refreshTime: 3, //nb minutes
+    },
+  },
   spamReportNfts: DEFAULT_FEATURE,
   lldWalletSync: DEFAULT_FEATURE,
+  llmWalletSync: DEFAULT_FEATURE,
   lldNftsGalleryNewArch: DEFAULT_FEATURE,
 };
 

package/src/featureFlags/groupedFeatures.ts

@@ -1,15 +1,14 @@
 import { FeatureId } from "@ledgerhq/types-live";
 
+export type GroupedFeature = "europa" | "disableNft";
+
 /** Helper to group several feature flag ids under a common feature flag */
 export const groupedFeatures: Record<
-  string,
+  GroupedFeature,
   {
     featureIds: FeatureId[];
   }
 > = {
-  stax: {
-    featureIds: ["supportDeviceStax", "deviceInitialApps", "staxWelcomeScreen"],
-  },
   europa: {
     featureIds: ["supportDeviceEuropa", "deviceInitialApps"],
   },

package/src/helpers.ts

@@ -9,3 +9,9 @@ export function includes<T extends U, U>(array: ReadonlyArray<T>, element: U): e
 export function objectKeysType<Type extends object>(value: Type): Array<keyof Type> {
   return Object.keys(value) as Array<keyof Type>;
 }
+
+export function reverseRecord<T extends PropertyKey, U extends PropertyKey>(
+  input: Record<T, U>,
+): Record<U, T> {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [value, key]));
+}

package/src/hw/getOnboardingStatePolling.ts

@@ -8,7 +8,7 @@ import {
   DeviceExtractOnboardingStateError,
   DisconnectedDevice,
   CantOpenDevice,
-  TransportPendingOperation,
+  TransportRaceCondition,
   LockedDeviceError,
   UnexpectedBootloader,
   TransportExchangeTimeoutError,
@@ -139,7 +139,7 @@ export const isAllowedOnboardingStatePollingError = (error: unknown): boolean =>
       error instanceof DisconnectedDevice ||
       error instanceof DisconnectedDeviceDuringOperation ||
       error instanceof CantOpenDevice ||
-      error instanceof TransportPendingOperation ||
+      error instanceof TransportRaceCondition ||
       error instanceof TransportStatusError ||
       // A locked device is handled as an allowed error
       error instanceof LockedDeviceError)

package/src/market/api/index.ts

@@ -0,0 +1,138 @@
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+import {
+  MarketCurrencyChartDataRequestParams,
+  MarketListRequestParams,
+  MarketPerformersParams,
+  MarketItemResponse,
+  SupportedCoins,
+  MarketCurrencyRequestParams,
+  MarketCoinDataChart,
+  Order,
+} from "../utils/types";
+import { rangeDataTable } from "../utils/rangeDataTable";
+import URL from "url";
+import { getRange, getSortParam } from "../utils";
+
+const baseURL = () => getEnv("LEDGER_COUNTERVALUES_API");
+const ROOT_PATH = getEnv("MARKET_API_URL");
+
+export async function getSupportedCoinsList(): Promise<SupportedCoins> {
+  const url = `${ROOT_PATH}/coins/list`;
+  const { data } = await network({ method: "GET", url });
+  return data;
+}
+
+// fetches currencies data for selected currencies ids
+export async function fetchList({
+  counterCurrency,
+  limit = 50,
+  page = 1,
+  order = Order.MarketCapDesc,
+  search = "",
+  liveCoinsList = [],
+  starred = [],
+  range = "24",
+}: MarketListRequestParams): Promise<MarketItemResponse[]> {
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      page: page,
+      pageSize: limit,
+      to: counterCurrency,
+      sort: getSortParam(order, range),
+      ...(search.length >= 1 && { filter: search }),
+      ...(starred.length > 0 && { ids: starred.join(",") }),
+      ...(liveCoinsList.length > 1 && { ids: liveCoinsList.join(",") }),
+      ...([Order.topLosers, Order.topGainers].includes(order) && { top: 100 }),
+    },
+  });
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return data;
+}
+
+// Fetches list of supported counterCurrencies
+export async function supportedCounterCurrencies(): Promise<string[]> {
+  const url = `${ROOT_PATH}/simple/supported_vs_currencies`;
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return data;
+}
+
+export async function fetchCurrencyChartData({
+  id,
+  counterCurrency,
+  range = "24h",
+}: MarketCurrencyChartDataRequestParams): Promise<MarketCoinDataChart> {
+  const { days, interval } = rangeDataTable[range];
+
+  const url = URL.format({
+    pathname: `${ROOT_PATH}/coins/${id}/market_chart`,
+    query: {
+      vs_currency: counterCurrency,
+      days,
+      interval,
+    },
+  });
+
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  return { [range]: data.prices };
+}
+
+export async function fetchCurrency({
+  counterCurrency,
+  id,
+}: MarketCurrencyRequestParams): Promise<MarketItemResponse> {
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      to: counterCurrency,
+      ids: id,
+      pageSize: 1,
+      limit: 1,
+    },
+  });
+
+  const { data } = await network({ method: "GET", url });
+
+  return data[0];
+}
+
+export async function fetchMarketPerformers({
+  counterCurrency,
+  range,
+  limit = 5,
+  top = 50,
+  sort,
+  supported,
+}: MarketPerformersParams): Promise<MarketItemResponse[]> {
+  const sortParam = `${sort === "asc" ? "positive" : "negative"}-price-change-${getRange(range)}`;
+
+  const url = URL.format({
+    pathname: `${baseURL()}/v3/markets`,
+    query: {
+      to: counterCurrency,
+      limit,
+      top,
+      sort: sortParam,
+      supported,
+    },
+  });
+
+  const { data } = await network({ method: "GET", url });
+
+  return data;
+}