@ledgerhq/live-common 25.1.0 → 25.2.0-next.0

package/src/reconciliation.ts

@@ -11,8 +11,7 @@ import type {
   SubAccount,
   SubAccountRaw,
   BalanceHistoryCache,
-  BalanceHistoryRawMap,
-} from "./types";
+} from "@ledgerhq/types-live";
 import {
   fromAccountRaw,
   fromOperationRaw,
@@ -20,7 +19,6 @@ import {
   fromTronResourcesRaw,
   fromCosmosResourcesRaw,
   fromBitcoinResourcesRaw,
-  fromBalanceHistoryRawMap,
   fromAlgorandResourcesRaw,
   fromPolkadotResourcesRaw,
   fromTezosResourcesRaw,
@@ -29,8 +27,25 @@ import {
   fromSolanaResourcesRaw,
   fromNFTRaw,
   fromCardanoResourceRaw,
+  toCryptoOrgResourcesRaw,
+  toSolanaResourcesRaw,
+  toCosmosResourcesRaw,
+  toTronResourcesRaw,
 } from "./account";
 import consoleWarnExpectToEqual from "./consoleWarnExpectToEqual";
+import { AlgorandAccount, AlgorandAccountRaw } from "./families/algorand/types";
+import { BitcoinAccount, BitcoinAccountRaw } from "./families/bitcoin/types";
+import { CardanoAccount, CardanoAccountRaw } from "./families/cardano/types";
+import { CosmosAccount, CosmosAccountRaw } from "./families/cosmos/types";
+import {
+  CryptoOrgAccount,
+  CryptoOrgAccountRaw,
+} from "./families/crypto_org/types";
+import { ElrondAccount, ElrondAccountRaw } from "./families/elrond/types";
+import { PolkadotAccount, PolkadotAccountRaw } from "./families/polkadot/types";
+import { SolanaAccount, SolanaAccountRaw } from "./families/solana/types";
+import { TezosAccount, TezosAccountRaw } from "./families/tezos/types";
+import { TronAccount, TronAccountRaw } from "./families/tron/types";
 
 // aim to build operations with the minimal diff & call to coin implementation possible
 export async function minimalOperationsBuilder<CO>(
@@ -137,37 +152,16 @@ const shouldRefreshBalanceHistoryCache = (
   return false;
 };
 
-// FIXME DEPRECATED post portfolio v2
-const shouldRefreshBalanceHistory = (
-  balanceHistory: BalanceHistoryRawMap,
-  account: Account
-): boolean => {
-  const { week } = balanceHistory;
-  const accountWeek = account.balanceHistory && account.balanceHistory.week;
-  if (!week || !accountWeek) return true; // there is no week yet || there were no balance history yet
-
-  const [firstDate] = week[0];
-  const [, lastValue] = week[week.length - 1];
-  const { date: firstAccountDate } = accountWeek[0];
-  const { value: lastAccountValue } = accountWeek[accountWeek.length - 1];
-  const isSameDate = firstDate === firstAccountDate.toISOString();
-  return (
-    !isSameDate || // start date of the range has changed
-    lastValue !== lastAccountValue.toString() || // final balance has changed
-    week.length !== accountWeek.length // number of endpoints has changed
-  );
-};
-
 function shouldRefreshBitcoinResources(
   updatedRaw: AccountRaw,
   account: Account
 ) {
-  if (!updatedRaw.bitcoinResources) return false;
-  if (!account.bitcoinResources) return true;
+  if (!(updatedRaw as BitcoinAccountRaw).bitcoinResources) return false;
+  if (!(account as BitcoinAccount).bitcoinResources) return true;
   if (updatedRaw.blockHeight !== account.blockHeight) return true;
   if (updatedRaw.operations.length !== account.operations.length) return true;
-  const { bitcoinResources: existing } = account;
-  const { bitcoinResources: raw } = updatedRaw;
+  const { bitcoinResources: existing } = account as BitcoinAccount;
+  const { bitcoinResources: raw } = updatedRaw as BitcoinAccountRaw;
   // FIXME Need more typing in wallet-btc to have a meaningful comparison
   //if (!isEqual(raw.walletAccount?.xpub?.data, existing.walletAccount?.xpub?.data)) return true;
   if (raw.utxos.length !== existing.utxos.length) return true;
@@ -245,19 +239,6 @@ export function patchAccount(
     changed = true;
   }
 
-  // DEPRECATED post portfolio v2
-  const { balanceHistory } = updatedRaw;
-
-  if (balanceHistory) {
-    if (shouldRefreshBalanceHistory(balanceHistory, account)) {
-      next.balanceHistory = fromBalanceHistoryRawMap(balanceHistory);
-      changed = true;
-    }
-  } else if (next.balanceHistory) {
-    delete next.balanceHistory;
-    changed = true;
-  }
-
   if (updatedRaw.spendableBalance !== account.spendableBalance.toString()) {
     next.spendableBalance = new BigNumber(
       updatedRaw.spendableBalance || updatedRaw.balance
@@ -307,95 +288,169 @@ export function patchAccount(
     }
   }
 
-  if (
-    updatedRaw.tronResources &&
-    // @ts-expect-error check if this is valid for deep equal check
-    account.tronResources !== updatedRaw.tronResources
-  ) {
-    next.tronResources = fromTronResourcesRaw(updatedRaw.tronResources);
-    changed = true;
-  }
-
-  if (
-    updatedRaw.cosmosResources &&
-    // @ts-expect-error check if this is valid for deep equal check
-    account.cosmosResources !== updatedRaw.cosmosResources
-  ) {
-    next.cosmosResources = fromCosmosResourcesRaw(updatedRaw.cosmosResources);
-    changed = true;
-  }
-
-  if (
-    updatedRaw.algorandResources &&
-    // @ts-expect-error check if this is valid for deep equal check
-    account.algorandResources !== updatedRaw.algorandResources
-  ) {
-    next.algorandResources = fromAlgorandResourcesRaw(
-      updatedRaw.algorandResources
-    );
-    changed = true;
-  }
-
-  if (
-    updatedRaw.bitcoinResources &&
-    shouldRefreshBitcoinResources(updatedRaw, account)
-  ) {
-    next.bitcoinResources = fromBitcoinResourcesRaw(
-      updatedRaw.bitcoinResources
-    );
-    changed = true;
-  }
-
-  if (
-    updatedRaw.polkadotResources &&
-    // @ts-expect-error check if this is valid for deep equal check
-    account.polkadotResources !== updatedRaw.polkadotResources
-  ) {
-    next.polkadotResources = fromPolkadotResourcesRaw(
-      updatedRaw.polkadotResources
-    );
-    changed = true;
-  }
-
-  if (
-    updatedRaw.tezosResources &&
-    account.tezosResources !== updatedRaw.tezosResources
-  ) {
-    next.tezosResources = fromTezosResourcesRaw(updatedRaw.tezosResources);
-    changed = true;
-  }
-
-  if (
-    updatedRaw.elrondResources &&
-    account.elrondResources !== updatedRaw.elrondResources
-  ) {
-    next.elrondResources = fromElrondResourcesRaw(updatedRaw.elrondResources);
-    changed = true;
-  }
-
-  if (
-    updatedRaw.cardanoResources &&
-    // @ts-expect-error check if this is valid for deep equal check
-    account.cardanoResources !== updatedRaw.cardanoResources
-  ) {
-    next.cardanoResources = fromCardanoResourceRaw(updatedRaw.cardanoResources);
-    changed = true;
-  }
-
-  if (
-    updatedRaw.cryptoOrgResources &&
-    // @ts-expect-error types don't overlap ¯\_(ツ)_/¯
-    account.cryptoOrgResources !== updatedRaw.cryptoOrgResources
-  ) {
-    next.cryptoOrgResources = fromCryptoOrgResourcesRaw(
-      updatedRaw.cryptoOrgResources
-    );
-    changed = true;
-  }
+  switch (account.currency.family) {
+    case "tron":
+      {
+        const tronAcc = account as TronAccount;
+        const tronUpdatedRaw = updatedRaw as TronAccountRaw;
+        if (
+          tronUpdatedRaw.tronResources &&
+          !areSameResources(
+            toTronResourcesRaw(tronAcc.tronResources),
+            tronUpdatedRaw.tronResources
+          )
+        ) {
+          (next as TronAccount).tronResources = fromTronResourcesRaw(
+            tronUpdatedRaw.tronResources
+          );
+          changed = true;
+        }
+      }
+      break;
+    case "cosmos": {
+      const cosmosAcc = account as CosmosAccount;
+      const cosmosUpdatedRaw = updatedRaw as CosmosAccountRaw;
+      if (
+        cosmosUpdatedRaw.cosmosResources &&
+        !areSameResources(
+          toCosmosResourcesRaw(cosmosAcc.cosmosResources),
+          cosmosUpdatedRaw.cosmosResources
+        )
+      ) {
+        (next as CosmosAccount).cosmosResources = fromCosmosResourcesRaw(
+          cosmosUpdatedRaw.cosmosResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "algorand": {
+      const algorandAcc = account as AlgorandAccount;
+      const algorandUpdatedRaw = updatedRaw as AlgorandAccountRaw;
+      if (
+        algorandUpdatedRaw.algorandResources &&
+        !areSameResources(
+          algorandAcc.algorandResources,
+          algorandUpdatedRaw.algorandResources
+        )
+      ) {
+        (next as AlgorandAccount).algorandResources = fromAlgorandResourcesRaw(
+          algorandUpdatedRaw.algorandResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "bitcoin": {
+      if (shouldRefreshBitcoinResources(updatedRaw, account)) {
+        (next as BitcoinAccount).bitcoinResources = fromBitcoinResourcesRaw(
+          (updatedRaw as BitcoinAccountRaw).bitcoinResources
+        );
+      }
+      break;
+    }
+    case "polkadot": {
+      const polkadotAcc = account as PolkadotAccount;
+      const polkadotUpdatedRaw = updatedRaw as PolkadotAccountRaw;
+      if (
+        polkadotUpdatedRaw.polkadotResources &&
+        !areSameResources(
+          polkadotAcc.polkadotResources,
+          polkadotUpdatedRaw.polkadotResources
+        )
+      ) {
+        (next as PolkadotAccount).polkadotResources = fromPolkadotResourcesRaw(
+          polkadotUpdatedRaw.polkadotResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "tezos": {
+      const tezosAcc = account as TezosAccount;
+      const tezosUpdatedRaw = updatedRaw as TezosAccountRaw;
+      if (
+        tezosUpdatedRaw.tezosResources &&
+        !areSameResources(
+          tezosAcc.tezosResources,
+          tezosUpdatedRaw.tezosResources
+        )
+      ) {
+        (next as TezosAccount).tezosResources = fromTezosResourcesRaw(
+          tezosUpdatedRaw.tezosResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "elrond": {
+      const elrondAcc = account as ElrondAccount;
+      const elrondUpdatedRaw = updatedRaw as ElrondAccountRaw;
+      if (
+        elrondUpdatedRaw.elrondResources &&
+        areSameResources(
+          elrondAcc.elrondResources,
+          elrondUpdatedRaw.elrondResources
+        )
+      ) {
+        (next as ElrondAccount).elrondResources = fromElrondResourcesRaw(
+          elrondUpdatedRaw.elrondResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "cardano": {
+      const cardanoAcc = account as CardanoAccount;
+      const cardanoUpdatedRaw = updatedRaw as CardanoAccountRaw;
+      if (
+        cardanoUpdatedRaw.cardanoResources &&
+        !areSameResources(
+          cardanoAcc.cardanoResources,
+          cardanoUpdatedRaw.cardanoResources
+        )
+      ) {
+        (next as CardanoAccount).cardanoResources = fromCardanoResourceRaw(
+          cardanoUpdatedRaw.cardanoResources
+        );
+        changed = true;
+      }
+      break;
+    }
+    case "crypto_org": {
+      const cryptoOrgAcc = account as CryptoOrgAccount;
+      const cryptoOrgUpdatedRaw = updatedRaw as CryptoOrgAccountRaw;
+      if (
+        cryptoOrgUpdatedRaw.cryptoOrgResources &&
+        !areSameResources(
+          toCryptoOrgResourcesRaw(cryptoOrgAcc.cryptoOrgResources),
+          cryptoOrgUpdatedRaw.cryptoOrgResources
+        )
+      ) {
+        (next as CryptoOrgAccount).cryptoOrgResources =
+          fromCryptoOrgResourcesRaw(cryptoOrgUpdatedRaw.cryptoOrgResources);
+        changed = true;
+      }
+      break;
+    }
+    case "solana": {
+      const solanaAcc = account as SolanaAccount;
+      const solanaUpdatedRaw = updatedRaw as SolanaAccountRaw;
 
-  if (updatedRaw.solanaResources) {
-    next.solanaResources = fromSolanaResourcesRaw(updatedRaw.solanaResources);
-    changed = true;
+      if (
+        solanaUpdatedRaw.solanaResources &&
+        !areSameResources(
+          toSolanaResourcesRaw(solanaAcc.solanaResources),
+          solanaUpdatedRaw.solanaResources
+        )
+      ) {
+        (next as SolanaAccount).solanaResources = fromSolanaResourcesRaw(
+          solanaUpdatedRaw.solanaResources
+        );
+        changed = true;
+      }
+      break;
+    }
   }
 
   const nfts = updatedRaw?.nfts?.map(fromNFTRaw);
@@ -595,3 +650,7 @@ function stepBuilder(state, newOp, i) {
     state.operations.push(newOp);
   }
 }
+
+export function areSameResources(a: any, b: any) {
+  return isEqual(a, b);
+}

package/src/transaction/common.ts

@@ -1,11 +1,18 @@
-import { BigNumber } from "bignumber.js";
+import { deserializeError, serializeError } from "@ledgerhq/errors";
 import type {
+  Account,
   TransactionCommon,
   TransactionCommonRaw,
-} from "../types/transaction";
-import type { Transaction, TransactionRaw } from "../types";
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { mapValues } from "lodash";
+import { getAccountUnit } from "../account";
+import { formatCurrencyUnit } from "../currencies";
+
 export const fromTransactionCommonRaw = (
-  raw: TransactionRaw
+  raw: TransactionCommonRaw
 ): TransactionCommon => {
   const common: TransactionCommon = {
     amount: new BigNumber(raw.amount),
@@ -23,7 +30,7 @@ export const fromTransactionCommonRaw = (
   return common;
 };
 export const toTransactionCommonRaw = (
-  raw: Transaction
+  raw: TransactionCommon
 ): TransactionCommonRaw => {
   const common: TransactionCommonRaw = {
     amount: raw.amount.toString(),
@@ -40,3 +47,91 @@ export const toTransactionCommonRaw = (
 
   return common;
 };
+
+const fromErrorRaw = (raw: string): Error => {
+  return deserializeError(JSON.parse(raw));
+};
+
+const toErrorRaw = (raw: Error): string =>
+  JSON.stringify(serializeError(raw)) || "{}";
+
+export const fromTransactionStatusRawCommon = (
+  ts: TransactionStatusCommonRaw
+): TransactionStatusCommon => ({
+  errors: mapValues(ts.errors, fromErrorRaw),
+  warnings: mapValues(ts.warnings, fromErrorRaw),
+  estimatedFees: new BigNumber(ts.estimatedFees),
+  amount: new BigNumber(ts.amount),
+  totalSpent: new BigNumber(ts.totalSpent),
+  recipientIsReadOnly: ts.recipientIsReadOnly,
+});
+
+export const toTransactionStatusRawCommon = (
+  ts: TransactionStatusCommon
+): TransactionStatusCommonRaw => ({
+  errors: mapValues(ts.errors, toErrorRaw),
+  warnings: mapValues(ts.warnings, toErrorRaw),
+  estimatedFees: ts.estimatedFees.toString(),
+  amount: ts.amount.toString(),
+  totalSpent: ts.totalSpent.toString(),
+  recipientIsReadOnly: ts.recipientIsReadOnly,
+});
+
+const formatErrorSmall = (e: Error): string =>
+  e.name === "Error" ? e.message : e.name;
+
+export const formatTransactionStatusCommon = (
+  t: TransactionCommon,
+  {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  }: TransactionStatusCommon,
+  mainAccount: Account
+): string => {
+  let str = "";
+  const account =
+    (t.subAccountId &&
+      (mainAccount.subAccounts || []).find((a) => a.id === t.subAccountId)) ||
+    mainAccount;
+
+  str +=
+    "\n  amount: " +
+    formatCurrencyUnit(getAccountUnit(account), amount, {
+      showCode: true,
+      disableRounding: true,
+    });
+  str +=
+    "\n  estimated fees: " +
+    formatCurrencyUnit(getAccountUnit(mainAccount), estimatedFees, {
+      showCode: true,
+      disableRounding: true,
+    });
+  str +=
+    "\n  total spent: " +
+    formatCurrencyUnit(getAccountUnit(account), totalSpent, {
+      showCode: true,
+      disableRounding: true,
+    });
+  const errorKeys = Object.keys(errors);
+
+  if (errorKeys.length) {
+    str +=
+      "\n  errors: " +
+      errorKeys.map((k) => `${k}: ${formatErrorSmall(errors[k])}`).join(", ");
+  }
+
+  const warningKeys = Object.keys(warnings);
+
+  if (warningKeys.length) {
+    str +=
+      "\n  warnings: " +
+      warningKeys
+        .map((k) => `${k}: ${formatErrorSmall(warnings[k])}`)
+        .join(", ");
+  }
+
+  return str;
+};

package/src/transaction/deviceTransactionConfig.ts

@@ -1,12 +1,8 @@
 import perFamily from "../generated/deviceTransactionConfig";
 import type { ExtraDeviceTransactionField } from "../generated/deviceTransactionConfig";
-import type {
-  Transaction,
-  TransactionStatus,
-  Account,
-  AccountLike,
-} from "../types";
+import type { Transaction, TransactionStatus } from "../generated/types";
 import { getMainAccount } from "../account";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
 type tooltipArgs = Record<string, string>;
 export type CommonDeviceTransactionField =
   | {

package/src/transaction/index.ts

@@ -1,9 +1,15 @@
 export * from "./common";
-export * from "./status";
 export * from "./signOperation";
 export * from "./deviceTransactionConfig";
-import type { Account, Transaction, TransactionRaw } from "../types";
+import type {
+  Transaction,
+  TransactionRaw,
+  TransactionStatus,
+  TransactionStatusRaw,
+} from "../generated/types";
 import transactionModulePerFamily from "../generated/transaction";
+import type { Account } from "@ledgerhq/types-live";
+
 export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   const TM = transactionModulePerFamily[tr.family];
   // FIXME: something is wrong with TM.fromTransactionRaw expecting a (arg: never) => for some reasons
@@ -14,8 +20,33 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
   // FIXME: something is wrong with TM.toTransactionRaw expecting a (arg: never) => for some reasons
   return TM.toTransactionRaw(t as any);
 };
+
+export const fromTransactionStatusRaw = (
+  tr: TransactionStatusRaw,
+  family: string
+): TransactionStatus => {
+  const TM = transactionModulePerFamily[family];
+  return TM.fromTransactionStatusRaw(tr as any);
+};
+export const toTransactionStatusRaw = (
+  t: TransactionStatus,
+  family: string
+): TransactionStatusRaw => {
+  const TM = transactionModulePerFamily[family];
+  return TM.toTransactionStatusRaw(t as any);
+};
+
 export const formatTransaction = (t: Transaction, a: Account): string => {
   const TM = transactionModulePerFamily[t.family];
   // FIXME: something is wrong with TM.formatTransaction expecting a (arg: never) => for some reasons
-  return TM.formatTransaction ? TM.formatTransaction(t as any, a) : "";
+  return TM.formatTransaction ? TM.formatTransaction(t as any, a as any) : "";
+};
+
+export const formatTransactionStatus = (
+  t: Transaction,
+  ts: TransactionStatus,
+  mainAccount: Account
+): string => {
+  const TM = transactionModulePerFamily[t.family];
+  return TM.formatTransactionStatus(t as any, ts as any, mainAccount as any);
 };

package/src/transaction/signOperation.ts

@@ -3,7 +3,7 @@ import type {
   SignOperationEvent,
   SignedOperationRaw,
   SignedOperation,
-} from "../types/transaction";
+} from "@ledgerhq/types-live";
 import { fromOperationRaw, toOperationRaw } from "../account";
 export const fromSignedOperationRaw = (
   signedOp: SignedOperationRaw,