@ledgerhq/live-common 24.1.0 → 25.0.0-next.1

package/src/families/stellar/speculos-deviceActions.ts

@@ -3,26 +3,44 @@ import type { Transaction } from "./types";
 import { formatCurrencyUnit } from "../../currencies";
 import { deviceActionFlow } from "../../bot/specs";
 
-const expectedAmount = ({ account, status }) =>
-  formatCurrencyUnit(account.unit, status.amount, {
-    disableRounding: true,
-    useGrouping: false,
-  }) + " XLM";
+const expectedAmount = ({ account, status, transaction }) => {
+  if (transaction.assetCode && transaction.assetIssuer) {
+    const amount = formatCurrencyUnit(account.unit, status.amount, {
+      disableRounding: true,
+      useGrouping: false,
+    });
+
+    return `${amount} ${transaction.assetCode}@${truncateAddress(
+      transaction.assetIssuer,
+      3,
+      4
+    )}`;
+  }
+
+  return (
+    formatCurrencyUnit(account.unit, status.amount, {
+      disableRounding: true,
+      useGrouping: false,
+    }) + " XLM"
+  );
+};
+
+const truncateAddress = (stellarAddress: string, start = 6, end = 6) =>
+  `${stellarAddress.slice(0, start)}..${stellarAddress.slice(-end)}`;
 
 const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
   steps: [
     {
-      title: "Starting Balance",
+      title: "Review",
       button: "Rr",
-      expectedValue: expectedAmount,
     },
     {
-      title: "Send",
+      title: "Memo Text",
       button: "Rr",
-      expectedValue: expectedAmount,
+      expectedValue: ({ transaction }) => transaction.memoValue || "",
     },
     {
-      title: "Fee",
+      title: "Max Fee",
       button: "Rr",
       expectedValue: ({ account, status }) =>
         formatCurrencyUnit(account.unit, status.estimatedFees, {
@@ -30,42 +48,68 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
         }) + " XLM",
     },
     {
-      title: "Destination",
+      title: "Sequence Num",
       button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
     },
     {
-      title: "Create Account",
+      title: "Tx Source",
       button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
+      expectedValue: ({ account }) => truncateAddress(account.freshAddress),
     },
     {
-      title: "Memo",
+      title: "Operation Type",
       button: "Rr",
-      expectedValue: ({ transaction }) => transaction.memoValue || "[none]",
+      // Operation type can be Payment (or Create Account) or Change Trust.
+      // Create Account type is coming from operation, not transaction.
+      // Testing in `specs.ts`.
     },
     {
-      title: "Network",
+      title: "Change Trust",
       button: "Rr",
-      expectedValue: () => "Public",
+      expectedValue: ({ transaction }) =>
+        `${transaction.assetCode || ""}@${truncateAddress(
+          transaction.assetIssuer || "",
+          3,
+          4
+        )}`,
+      maxY: 5,
     },
     {
-      title: "Time Bounds",
+      title: "Create Account",
       button: "Rr",
+      expectedValue: ({ transaction }) => transaction.recipient,
+      maxY: 5,
     },
     {
-      title: "Tx Source",
+      title: "Send",
       button: "Rr",
-      expectedValue: ({ account }) => account.freshAddress,
+      expectedValue: expectedAmount,
     },
     {
-      title: "Review",
+      title: "Destination",
       button: "Rr",
+      expectedValue: ({ transaction }) => transaction.recipient,
     },
     {
       title: "Finalize",
       button: "LRlr",
     },
+    {
+      title: "Starting Balance",
+      button: "Rr",
+    },
+    {
+      title: "Network",
+      button: "Rr",
+    },
+    {
+      title: "Valid Before (UTC)",
+      button: "Rr",
+    },
+    {
+      title: "Valid After (UTC)",
+      button: "Rr",
+    },
   ],
 });
 export default {

package/src/families/stellar/tokens.ts

@@ -0,0 +1,118 @@
+import BigNumber from "bignumber.js";
+import { emptyHistoryCache } from "../../account";
+import {
+  listTokensForCryptoCurrency,
+  findTokenById,
+  parseCurrencyUnit,
+} from "../../currencies";
+import type {
+  TokenAccount,
+  TokenCurrency,
+  Operation,
+  CryptoCurrency,
+  SyncConfig,
+} from "../../types";
+import type { BalanceAsset } from "./types";
+import { encodeOperationId } from "../../operation";
+
+export const getAssetIdFromTokenId = (tokenId: string): string =>
+  tokenId.split("/")[2];
+
+const getAssetIdFromAsset = (asset: BalanceAsset) =>
+  `${asset.asset_code}:${asset.asset_issuer}`;
+
+const buildStellarTokenAccount = ({
+  parentAccountId,
+  stellarAsset,
+  token,
+  operations,
+}: {
+  parentAccountId: string;
+  stellarAsset: BalanceAsset;
+  token: TokenCurrency;
+  operations: Operation[];
+}): TokenAccount => {
+  const assetId = getAssetIdFromTokenId(token.id);
+  const id = `${parentAccountId}+${assetId}`;
+  const balance = parseCurrencyUnit(
+    token.units[0],
+    stellarAsset.balance || "0"
+  );
+
+  const reservedBalance = new BigNumber(stellarAsset.balance).minus(
+    stellarAsset.buying_liabilities || 0
+  );
+  const spendableBalance = parseCurrencyUnit(
+    token.units[0],
+    reservedBalance.toString()
+  );
+
+  return {
+    type: "TokenAccount",
+    id,
+    parentId: parentAccountId,
+    starred: false,
+    token,
+    operationsCount: operations.length,
+    operations: operations.map((op) => ({
+      ...op,
+      id: encodeOperationId(id, op.hash, op.extra.ledgerOpType),
+      accountId: id,
+      type: op.extra.ledgerOpType,
+      value: new BigNumber(op.extra.assetAmount) ?? op.value,
+    })),
+    pendingOperations: [],
+    balance,
+    spendableBalance,
+    swapHistory: [],
+    creationDate:
+      operations.length > 0
+        ? operations[operations.length - 1].date
+        : new Date(),
+    balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+  };
+};
+
+export const buildSubAccounts = ({
+  currency,
+  accountId,
+  assets,
+  syncConfig,
+  operations,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  assets: BalanceAsset[];
+  syncConfig: SyncConfig;
+  operations: Operation[];
+}): TokenAccount[] | undefined => {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  const allTokens = listTokensForCryptoCurrency(currency);
+
+  if (allTokens.length === 0 || assets.length === 0) {
+    return undefined;
+  }
+
+  const tokenAccounts: TokenAccount[] = [];
+
+  assets.map((asset) => {
+    const token = findTokenById(`stellar/asset/${getAssetIdFromAsset(asset)}`);
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      tokenAccounts.push(
+        buildStellarTokenAccount({
+          parentAccountId: accountId,
+          stellarAsset: asset,
+          token,
+          operations: operations.filter(
+            (op) =>
+              op.extra.assetCode === asset.asset_code &&
+              op.extra.assetIssuer === asset.asset_issuer
+          ),
+        })
+      );
+    }
+  });
+
+  return tokenAccounts;
+};

package/src/families/stellar/transaction.ts

@@ -1,5 +1,6 @@
 import { BigNumber } from "bignumber.js";
 import type { Transaction, TransactionRaw } from "./types";
+import { getAssetCodeIssuer } from "./logic";
 import {
   fromTransactionCommonRaw,
   toTransactionCommonRaw,
@@ -9,9 +10,22 @@ import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 
 export const formatTransaction = (
-  { amount, recipient, fees, memoValue, useAllAmount }: Transaction,
-  account: Account
-): string => `
+  {
+    amount,
+    recipient,
+    fees,
+    memoValue,
+    useAllAmount,
+    subAccountId,
+  }: Transaction,
+  mainAccount: Account
+): string => {
+  const account =
+    (subAccountId &&
+      (mainAccount.subAccounts || []).find((a) => a.id === subAccountId)) ||
+    mainAccount;
+
+  return `
     SEND ${
       useAllAmount
         ? "MAX"
@@ -29,10 +43,13 @@ export const formatTransaction = (
             disableRounding: true,
           })
     }${memoValue ? "\n  memo=" + memoValue : ""}`;
+};
 
 const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   const common = fromTransactionCommonRaw(tr);
   const { networkInfo } = tr;
+  const [assetCode, assetIssuer] = getAssetCodeIssuer(tr);
+
   return {
     ...common,
     family: tr.family,
@@ -43,14 +60,20 @@ const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     networkInfo: networkInfo && {
       family: networkInfo.family,
       fees: new BigNumber(networkInfo.fees),
+      baseFee: new BigNumber(networkInfo.baseFee),
       baseReserve: new BigNumber(networkInfo.baseReserve),
+      networkCongestionLevel: networkInfo.networkCongestionLevel,
     },
+    mode: tr.mode,
+    assetCode,
+    assetIssuer,
   };
 };
 
 const toTransactionRaw = (t: Transaction): TransactionRaw => {
   const common = toTransactionCommonRaw(t);
   const { networkInfo } = t;
+  const [assetCode, assetIssuer] = getAssetCodeIssuer(t);
   return {
     ...common,
     family: t.family,
@@ -61,8 +84,13 @@ const toTransactionRaw = (t: Transaction): TransactionRaw => {
     networkInfo: networkInfo && {
       family: networkInfo.family,
       fees: networkInfo.fees.toString(),
+      baseFee: networkInfo.baseFee.toString(),
       baseReserve: networkInfo.baseReserve.toString(),
+      networkCongestionLevel: networkInfo.networkCongestionLevel,
     },
+    mode: t.mode,
+    assetCode,
+    assetIssuer,
   };
 };
 

package/src/families/stellar/types.ts

@@ -1,3 +1,4 @@
+import { ServerApi } from "stellar-sdk";
 import type { BigNumber } from "bignumber.js";
 import type {
   TransactionCommon,
@@ -7,14 +8,25 @@ import type {
 export type NetworkInfo = {
   family: "stellar";
   fees: BigNumber;
+  baseFee: BigNumber;
   baseReserve: BigNumber;
+  networkCongestionLevel?: NetworkCongestionLevel;
 };
 
 export type NetworkInfoRaw = {
   family: "stellar";
   fees: string;
+  baseFee: string;
   baseReserve: string;
+  networkCongestionLevel?: NetworkCongestionLevel;
 };
+
+export enum NetworkCongestionLevel {
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+  HIGH = "HIGH",
+}
+
 export const StellarMemoType = [
   "NO_MEMO",
   "MEMO_TEXT",
@@ -23,6 +35,8 @@ export const StellarMemoType = [
   "MEMO_RETURN",
 ];
 
+export type StellarTransactionMode = "send" | "changeTrust";
+
 export type Transaction = TransactionCommon & {
   family: "stellar";
   networkInfo: NetworkInfo | null | undefined;
@@ -30,7 +44,11 @@ export type Transaction = TransactionCommon & {
   baseReserve: BigNumber | null | undefined;
   memoType: string | null | undefined;
   memoValue: string | null | undefined;
+  mode: StellarTransactionMode;
+  assetCode: string | undefined;
+  assetIssuer: string | undefined;
 };
+
 export type TransactionRaw = TransactionCommonRaw & {
   family: "stellar";
   networkInfo: NetworkInfoRaw | null | undefined;
@@ -38,4 +56,38 @@ export type TransactionRaw = TransactionCommonRaw & {
   baseReserve: string | null | undefined;
   memoType: string | null | undefined;
   memoValue: string | null | undefined;
+  mode: StellarTransactionMode;
+  assetCode: string | undefined;
+  assetIssuer: string | undefined;
+};
+
+export type BalanceAsset = {
+  balance: string;
+  limit: string;
+  buying_liabilities: string;
+  selling_liabilities: string;
+  last_modified_ledger: number;
+  is_authorized: boolean;
+  is_authorized_to_maintain_liabilities: boolean;
+  asset_type: string;
+  asset_code: string;
+  asset_issuer: string;
+  liquidity_pool_id?: string;
+};
+
+export type RawOperation = ServerApi.OperationRecord & {
+  asset_code?: string;
+  asset_issuer?: string;
+  from?: string;
+  to?: string;
+  funder?: string;
+  trustor?: string;
+  account?: string;
+  transaction_successful: boolean;
+};
+
+export type Signer = {
+  weight: number;
+  key: string;
+  type: string;
 };

package/src/families/tezos/exchange.ts

@@ -1,4 +1,4 @@
-import { bip32asBuffer } from "@ledgerhq/hw-app-btc/lib/bip32";
+import { bip32asBuffer } from "@ledgerhq/hw-app-btc/bip32";
 
 const getSerializedAddressParameters = (
   path: string

package/src/hw/signMessage/index.test.ts

@@ -0,0 +1,128 @@
+import BigNumber from "bignumber.js";
+import { Account, CryptoCurrency } from "../../types";
+import { prepareMessageToSign } from "./index";
+import { MessageData } from "./types";
+
+describe("prepareMessageToSign", () => {
+  it("returns the prepared data from a simple string", () => {
+    // Given
+    const crypto = createCryptoCurrency("ethereum");
+    const account = createAccount(crypto);
+    const message = "Message de test";
+    const expectedRawMessage = "0x4d6573736167652064652074657374";
+
+    // When
+    let result: MessageData | null = null;
+    let error: unknown = null;
+    try {
+      result = prepareMessageToSign(account, message);
+    } catch (err) {
+      error = err;
+    }
+
+    // Then
+    expect(error).toBeNull();
+    expect(result).toEqual({
+      currency: crypto,
+      path: "44'/60'/0'/0/0",
+      derivationMode: "ethM",
+      message: "Message de test",
+      rawMessage: expectedRawMessage,
+    });
+  });
+
+  it("returns an error if account is not linked to a crypto able to sign a message", () => {
+    // Given
+    const crypto = createCryptoCurrency("mycoin");
+    const account = createAccount(crypto);
+    const message = "Message de test";
+
+    // When
+    let result: MessageData | null = null;
+    let error: Error | null = null;
+    try {
+      result = prepareMessageToSign(account, message);
+    } catch (err) {
+      error = err as Error;
+    }
+
+    // Then
+    expect(result).toBeNull();
+    expect(error).toEqual(Error("Crypto does not support signMessage"));
+  });
+});
+
+const createCryptoCurrency = (family: string): CryptoCurrency => ({
+  type: "CryptoCurrency",
+  id: "testCoinId",
+  coinType: 8008,
+  name: "MyCoin",
+  managerAppName: "MyCoin",
+  ticker: "MYC",
+  countervalueTicker: "MYC",
+  scheme: "mycoin",
+  color: "#ff0000",
+  family,
+  units: [
+    {
+      name: "MYC",
+      code: "MYC",
+      magnitude: 8,
+    },
+    {
+      name: "SmallestUnit",
+      code: "SMALLESTUNIT",
+      magnitude: 0,
+    },
+  ],
+  explorerViews: [
+    {
+      address: "https://mycoinexplorer.com/account/$address",
+      tx: "https://mycoinexplorer.com/transaction/$hash",
+      token: "https://mycoinexplorer.com/token/$contractAddress/?a=$address",
+    },
+  ],
+});
+
+const createAccount = (crypto: CryptoCurrency): Account => ({
+  type: "Account",
+  id: "ethereumjs:2:ethereum:0x01:",
+  seedIdentifier: "0x01",
+  derivationMode: "ethM",
+  index: 0,
+  freshAddress: "0x01",
+  freshAddressPath: "44'/60'/0'/0/0",
+  freshAddresses: [],
+  name: "Ethereum 1",
+  starred: false,
+  used: false,
+  balance: new BigNumber("51281813126095913"),
+  spendableBalance: new BigNumber("51281813126095913"),
+  creationDate: new Date(),
+  blockHeight: 8168983,
+  currency: crypto,
+  unit: {
+    name: "satoshi",
+    code: "BTC",
+    magnitude: 5,
+  },
+  operationsCount: 0,
+  operations: [],
+  pendingOperations: [],
+  lastSyncDate: new Date(),
+  balanceHistoryCache: {
+    HOUR: {
+      balances: [],
+      latestDate: undefined,
+    },
+    DAY: {
+      balances: [],
+      latestDate: undefined,
+    },
+    WEEK: {
+      balances: [],
+      latestDate: undefined,
+    },
+  },
+  swapHistory: [],
+});

package/src/hw/signMessage/index.ts

@@ -1,26 +1,42 @@
-import invariant from "invariant";
 import {
   DeviceAppVerifyNotSupported,
   UserRefusedAddress,
 } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
-import { Observable } from "rxjs";
-import type { Resolver } from "./types";
+import invariant from "invariant";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { from, Observable } from "rxjs";
 import perFamily from "../../generated/hw-signMessage";
-import { useState, useEffect, useCallback, useRef } from "react";
-import { from } from "rxjs";
-import { createAction as createAppAction } from "../actions/app";
+import { Account } from "../../types";
 import type { AppRequest, AppState } from "../actions/app";
+import { createAction as createAppAction } from "../actions/app";
 import type { Device } from "../actions/types";
 import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
 import { withDevice } from "../deviceAccess";
-import type { MessageData, Result } from "./types";
+import type { MessageData, Resolver, Result } from "./types";
+
+export const prepareMessageToSign = (
+  { currency, freshAddressPath, derivationMode }: Account,
+  message: string
+): MessageData | null => {
+  if (!perFamily[currency.family]) {
+    throw new Error("Crypto does not support signMessage");
+  }
+
+  return {
+    currency: currency,
+    path: freshAddressPath,
+    derivationMode: derivationMode,
+    message: message,
+    rawMessage: "0x" + Buffer.from(message).toString("hex"),
+  };
+};
 
 const dispatch: Resolver = (transport, opts) => {
   const { currency, verify } = opts;
-  const getAddress = perFamily[currency.family];
-  invariant(getAddress, `signMessage is not implemented for ${currency.id}`);
-  return getAddress(transport, opts)
+  const signMessage = perFamily[currency.family];
+  invariant(signMessage, `signMessage is not implemented for ${currency.id}`);
+  return signMessage(transport, opts)
     .then((result) => {
       log(
         "hw",
@@ -59,24 +75,28 @@ export type State = AppState & BaseState;
 export type Request = AppRequest & {
   message: MessageData;
 };
+
 export type Input = {
   request: Request;
   deviceId: string;
 };
+
 export const signMessageExec = ({
   request,
   deviceId,
 }: Input): Observable<Result> => {
-  const result: Observable<Result> = withDevice(deviceId)((t) =>
-    from(dispatch(t, request.message))
+  const result: Observable<Result> = withDevice(deviceId)((transport) =>
+    from(dispatch(transport, request.message))
   );
   return result;
 };
+
 const initialState: BaseState = {
   signMessageRequested: null,
   signMessageError: null,
   signMessageResult: null,
 };
+
 export const createAction = (
   connectAppExec: (arg0: ConnectAppInput) => Observable<ConnectAppEvent>,
   signMessage: (arg0: Input) => Observable<Result> = signMessageExec
@@ -97,6 +117,7 @@ export const createAction = (
       signMessageRequested: request.message,
     });
     const signedFired = useRef<boolean>();
+
     const sign = useCallback(async () => {
       let result;
 
@@ -124,6 +145,7 @@ export const createAction = (
 
       setState({ ...initialState, signMessageResult: result?.signature });
     }, [device, request]);
+
     useEffect(() => {
       if (!device || !opened || inWrongDeviceForAccount || error) {
         return;
@@ -146,9 +168,9 @@ export const createAction = (
 
   return {
     useHook,
-    mapResult: (r: State) => ({
-      signature: r.signMessageResult,
-      error: r.signMessageError,
+    mapResult: (state: State) => ({
+      signature: state.signMessageResult,
+      error: state.signMessageError,
     }),
   };
 };

package/src/load/speculos.ts

@@ -316,9 +316,7 @@ export function appCandidatesMatches(
           hackBadSemver(appCandidate.firmware),
           searchFirmware
         ))) &&
-    ((!search.appVersion &&
-      !appCandidate.appVersion.includes("prerelease") &&
-      !appCandidate.appVersion.includes("rc")) ||
+    ((!search.appVersion && !appCandidate.appVersion.includes("-")) ||
       (search.appVersion &&
         semver.satisfies(appCandidate.appVersion, search.appVersion)))
   );

package/src/mock/Btc.ts

@@ -1,5 +1,5 @@
 import Btc, { AddressFormat } from "@ledgerhq/hw-app-btc";
-import { CreateTransactionArg } from "@ledgerhq/hw-app-btc/lib/createTransaction";
+import { CreateTransactionArg } from "@ledgerhq/hw-app-btc/createTransaction";
 import Transport from "@ledgerhq/hw-transport";
 import hash from "object-hash";