@ledgerhq/live-common 25.0.0-next.3 → 25.0.0-next.6

package/src/families/cardano/js-synchronisation.ts

@@ -21,6 +21,7 @@ import {
   getMemoFromTx,
   getOperationType,
   isHexString,
+  mergeTokens,
 } from "./logic";
 import { encodeOperationId } from "../../operation";
 import { getNetworkParameters } from "./networks";
@@ -28,6 +29,9 @@ import { getNetworkInfo } from "./api/getNetworkInfo";
 import uniqBy from "lodash/uniqBy";
 import postSyncPatch from "./postSyncPatch";
 import { getTransactions } from "./api/getTransactions";
+import { buildSubAccounts } from "./buildSubAccounts";
+import { calculateMinUtxoAmount } from "@stricahq/typhonjs/dist/utils/utils";
+import { listTokensForCryptoCurrency } from "../../currencies";
 
 function mapTxToAccountOperation(
   tx: APITransaction,
@@ -43,6 +47,10 @@ function mapTxToAccountOperation(
 
   const subOperations = inferSubOperations(tx.hash, subAccounts);
   const memo = getMemoFromTx(tx);
+  const extra = {};
+  if (memo) {
+    extra["memo"] = memo;
+  }
 
   return {
     accountId,
@@ -64,14 +72,12 @@ function mapTxToAccountOperation(
     subOperations,
     blockHeight: tx.blockHeight,
     date: new Date(tx.timestamp),
-    extra: {
-      memo,
-    },
+    extra: extra,
     blockHash: undefined,
   };
 }
 
-function syncUtxos(
+function prepareUtxos(
   newTransactions: Array<APITransaction>,
   stableUtxos: Array<CardanoOutput>,
   accountCredentialsMap: Record<string, PaymentCredential>
@@ -116,7 +122,10 @@ function syncUtxos(
   return utxos;
 }
 
-export const getAccountShape: GetAccountShape = async (info) => {
+export const getAccountShape: GetAccountShape = async (
+  info,
+  { blacklistedTokenIds }
+) => {
   const {
     transport,
     currency,
@@ -152,16 +161,27 @@ export const getAccountShape: GetAccountShape = async (info) => {
     derivationMode,
   });
 
+  // when new tokens are added / blacklist changes, we need to sync again because we need to go through all operations again
+  const syncHash =
+    JSON.stringify(blacklistedTokenIds || []) +
+    "_" +
+    listTokensForCryptoCurrency(currency, {
+      withDelisted: true,
+    }).length;
+  const outdatedSyncHash = initialAccount?.syncHash !== syncHash;
+
   const requiredConfirmations = 90;
 
   const oldOperations = initialAccount?.operations || [];
   const lastBlockHeight = oldOperations.length
     ? (oldOperations[0].blockHeight || 0) + 1
     : 0;
-  const syncFromBlockHeight =
-    lastBlockHeight > requiredConfirmations
-      ? lastBlockHeight - requiredConfirmations
-      : 0;
+
+  const syncFromBlockHeight = outdatedSyncHash
+    ? 0
+    : lastBlockHeight > requiredConfirmations
+    ? lastBlockHeight - requiredConfirmations
+    : 0;
 
   const {
     transactions: newTransactions,
@@ -195,21 +215,24 @@ export const getAccountShape: GetAccountShape = async (info) => {
     (u) => stableOperationsByIds[u.hash]
   );
 
-  const utxos = syncUtxos(newTransactions, stableUtxos, accountCredentialsMap);
+  const utxos = prepareUtxos(
+    newTransactions,
+    stableUtxos,
+    accountCredentialsMap
+  );
   const accountBalance = utxos.reduce(
     (total, u) => total.plus(u.amount),
     new BigNumber(0)
   );
-  // const tokenBalance = mergeTokens(utxos.map((u) => u.tokens).flat());
-  // const subAccounts = buildSubAccounts({
-  //   initialAccount,
-  //   parentAccountId: accountId,
-  //   parentCurrency: currency,
-  //   newTransactions,
-  //   tokens: tokenBalance,
-  //   accountCredentialsMap,
-  // });
-  const subAccounts = [];
+  const tokenBalance = mergeTokens(utxos.map((u) => u.tokens).flat());
+  const subAccounts = buildSubAccounts({
+    initialAccount,
+    parentAccountId: accountId,
+    parentCurrency: currency,
+    newTransactions,
+    tokens: tokenBalance,
+    accountCredentialsMap,
+  });
 
   const newOperations = newTransactions.map((t) =>
     mapTxToAccountOperation(t, accountId, accountCredentialsMap, subAccounts)
@@ -233,13 +256,21 @@ export const getAccountShape: GetAccountShape = async (info) => {
       }).getBech32(),
     }));
   const cardanoNetworkInfo = await getNetworkInfo(initialAccount, currency);
+  const minAdaBalanceForTokens = tokenBalance.length
+    ? calculateMinUtxoAmount(
+        tokenBalance,
+        new BigNumber(cardanoNetworkInfo.protocolParams.lovelacePerUtxoWord),
+        false
+      )
+    : new BigNumber(0);
 
   return {
     id: accountId,
     xpub,
     balance: accountBalance,
-    spendableBalance: accountBalance,
+    spendableBalance: accountBalance.minus(minAdaBalanceForTokens),
     operations: operations,
+    syncHash,
     subAccounts,
     freshAddresses,
     freshAddress: freshAddresses[0].address,

package/src/families/cardano/js-transaction.ts

@@ -47,7 +47,7 @@ export const prepareTransaction = async (
   try {
     transaction = await buildTransaction(a, t);
   } catch (error) {
-    return { ...t, fees: new BigNumber(0), amount: new BigNumber(0) };
+    return { ...t, fees: new BigNumber(0), amount: t.amount };
   }
 
   const transactionFees = transaction.getFee();

package/src/families/cardano/logic.ts

@@ -448,3 +448,13 @@ export function isHexString(value: string): boolean {
   const regExp = /^[0-9a-fA-F]+$/;
   return regExp.test(value);
 }
+
+export function decodeTokenName(assetName: string): string {
+  if (assetName.length > 0) {
+    const bytes = [...Buffer.from(assetName, "hex")];
+    if (bytes.filter((byte) => byte <= 32 || byte >= 127).length === 0) {
+      return String.fromCharCode(...bytes);
+    }
+  }
+  return assetName;
+}

package/src/families/cardano/specs.ts

@@ -9,10 +9,15 @@ import invariant from "invariant";
 import { utils as TyphonUtils } from "@stricahq/typhonjs";
 import { mergeTokens } from "./logic";
 import { parseCurrencyUnit } from "../../currencies";
+import { SubAccount } from "../../types";
 
 const currency = getCryptoCurrencyById("cardano");
 const minBalanceRequired = parseCurrencyUnit(currency.units[0], "2.2");
 const minBalanceRequiredForMaxSend = parseCurrencyUnit(currency.units[0], "1");
+const minSpendableRequiredForTokenTx = parseCurrencyUnit(
+  currency.units[0],
+  "3"
+);
 
 const cardano: AppSpec<Transaction> = {
   name: "cardano",
@@ -34,7 +39,12 @@ const cardano: AppSpec<Transaction> = {
 
         const updates = [
           { recipient },
-          { amount: new BigNumber(account.balance.dividedBy(2)).dp(0, 1) },
+          {
+            amount: new BigNumber(account.balance.dividedBy(2)).dp(
+              0,
+              BigNumber.ROUND_CEIL
+            ),
+          },
           { memo: "LedgerLiveBot" },
         ];
 
@@ -90,6 +100,48 @@ const cardano: AppSpec<Transaction> = {
         );
       },
     },
+    {
+      name: "move ~10% token",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(
+          maxSpendable.gte(minSpendableRequiredForTokenTx),
+          "balance is too low"
+        );
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const subAccount = account.subAccounts?.find((subAccount) =>
+          subAccount.balance.gt(1)
+        ) as SubAccount;
+        invariant(subAccount, "No token account with balance");
+
+        const updates = [
+          { subAccountId: subAccount.id },
+          { recipient },
+          {
+            amount: new BigNumber(subAccount.balance.dividedBy(10)).dp(
+              0,
+              BigNumber.ROUND_CEIL
+            ),
+          },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        expect(operation.subOperations).toBeTruthy();
+        expect(operation.subOperations?.length).toEqual(1);
+
+        const subOperation =
+          operation.subOperations && operation.subOperations[0];
+        expect(subOperation?.value).toEqual(transaction.amount);
+      },
+    },
   ],
 };
 

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

@@ -39,6 +39,21 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
       expectedValue: ({ account, status }) =>
         expectedValue(account.unit, status.amount),
     },
+    {
+      title: "Asset fingerprint",
+      button: "LRlr",
+    },
+    {
+      title: "Token amount",
+      button: "LRlr",
+    },
+    {
+      title: "Confirm",
+    },
+    {
+      title: "output?",
+      button: "Rr",
+    },
     {
       title: "Transaction fee",
       button: "LRlr",

package/src/families/cosmos/react.ts

@@ -165,19 +165,27 @@ export function useMappedExtraOperationDetails({
   };
 }
 
-export function useLedgerFirstShuffledValidatorsCosmos() {
+export function useLedgerFirstShuffledValidatorsCosmos(
+  searchInput?: string
+): CosmosValidatorItem[] {
   const data = useCosmosPreloadData();
 
   return useMemo(() => {
-    return reorderValidators(data?.validators ?? []);
-  }, [data]);
+    return reorderValidators(data?.validators ?? [], searchInput);
+  }, [data, searchInput]);
 }
 
 function reorderValidators(
-  validators: CosmosValidatorItem[]
+  validators: CosmosValidatorItem[],
+  searchInput?: string
 ): CosmosValidatorItem[] {
   const sortedValidators = validators
     .filter((validator) => validator.commission !== 1.0)
+    .filter((validator) =>
+      searchInput
+        ? validator.name.toLowerCase().includes(searchInput.toLowerCase())
+        : true
+    )
     .sort((a, b) => b.votingPower - a.votingPower);
 
   // move Ledger validator to the first position

package/src/families/hedera/api/mirror.ts

@@ -136,7 +136,7 @@ export async function getOperationsForAccount(
       // Set a value just so that it's considered confirmed according to isConfirmedOperation
       blockHeight: 5,
       blockHash: null,
-      extra: { consensus_timestamp },
+      extra: {},
       fee,
       hash,
       recipients,

package/src/families/hedera/api/network.ts

@@ -23,6 +23,7 @@ export async function buildUnsignedTransaction({
   return new hedera.TransferTransaction()
     .setNodeAccountIds([new AccountId(3)])
     .setTransactionId(hedera.TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
     .addHbarTransfer(accountId, hbarAmount.negated())
     .addHbarTransfer(transaction.recipient, hbarAmount)
     .freeze();

package/src/families/hedera/deviceTransactionConfig.ts

@@ -39,6 +39,14 @@ function getDeviceTransactionConfig({
     });
   }
 
+  if (transaction.memo) {
+    fields.push({
+      type: "text",
+      label: "Memo",
+      value: transaction.memo,
+    });
+  }
+
   return fields;
 }
 

package/src/families/hedera/js-synchronisation.ts

@@ -1,4 +1,5 @@
 import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
 import { Account, getDerivationScheme, runDerivationScheme } from "../../types";
 import type {
   GetAccountShape,
@@ -31,14 +32,15 @@ const getAccountShape: GetAccountShape = async (
 
   // grab latest operation's consensus timestamp for incremental sync
   const oldOperations = initialAccount?.operations ?? [];
-  const latestOperationTimestamp =
-    oldOperations[0]?.extra?.consensus_timestamp ?? 0;
+  const latestOperationTimestamp = oldOperations[0]
+    ? Math.floor(oldOperations[0].date.getTime() / 1000)
+    : 0;
 
   // merge new operations w/ previously synced ones
   const newOperations = await getOperationsForAccount(
     liveAccountId,
     address,
-    latestOperationTimestamp
+    new BigNumber(latestOperationTimestamp).toString()
   );
   const operations = mergeOps(oldOperations, newOperations);
 

package/src/families/hedera/specs.ts

@@ -2,12 +2,18 @@ import expect from "expect";
 import invariant from "invariant";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { DeviceModelId } from "@ledgerhq/devices";
-import type { AppSpec } from "../../bot/types";
+import type {
+  AppSpec,
+  TransactionTestInput,
+  TransactionArg,
+  TransactionRes,
+} from "../../bot/types";
 import type { Transaction } from "./types";
 import { pickSiblings } from "../../bot/specs";
 import { isAccountEmpty } from "../../account";
 
 const currency = getCryptoCurrencyById("hedera");
+const memoTestMessage = "This is a test memo.";
 
 // Ensure that, when the recipient corresponds to an empty account,
 // the amount to send is greater or equal to the required minimum
@@ -41,7 +47,11 @@ const hedera: AppSpec<Transaction> = {
     {
       name: "Send ~50%",
       maxRun: 2,
-      transaction: ({ account, siblings, bridge }) => {
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
         const sibling = pickSiblings(siblings, 4);
         const recipient = sibling.freshAddress;
 
@@ -58,7 +68,11 @@ const hedera: AppSpec<Transaction> = {
           updates: [{ amount }, { recipient }],
         };
       },
-      test: ({ account, accountBeforeTransaction, operation }) => {
+      test: ({
+        account,
+        accountBeforeTransaction,
+        operation,
+      }: TransactionTestInput<Transaction>): void => {
         expect(account.balance.toString()).toBe(
           accountBeforeTransaction.balance.minus(operation.value).toString()
         );
@@ -67,7 +81,11 @@ const hedera: AppSpec<Transaction> = {
     {
       name: "Send max",
       maxRun: 2,
-      transaction: ({ account, siblings, bridge }) => {
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
         const sibling = pickSiblings(siblings, 4);
         const recipient = sibling.freshAddress;
 
@@ -78,7 +96,12 @@ const hedera: AppSpec<Transaction> = {
           updates: [{ recipient }, { useAllAmount: true }],
         };
       },
-      test: ({ accountBeforeTransaction, account, operation, transaction }) => {
+      test: ({
+        accountBeforeTransaction,
+        account,
+        operation,
+        transaction,
+      }: TransactionTestInput<Transaction>): void => {
         const accountBalanceAfterTx = account.balance.toNumber();
 
         // NOTE: operation.fee is the ACTUAL (not estimated) fee cost of the transaction
@@ -89,6 +112,34 @@ const hedera: AppSpec<Transaction> = {
         expect(accountBalanceAfterTx).toBe(amount);
       },
     },
+    {
+      name: "Memo",
+      maxRun: 2,
+      transaction: ({
+        account,
+        siblings,
+        bridge,
+      }: TransactionArg<Transaction>): TransactionRes<Transaction> => {
+        const sibling = pickSiblings(siblings, 4);
+        const recipient = sibling.freshAddress;
+
+        const transaction = bridge.createTransaction(account);
+
+        const amount = account.balance
+          .div(1.9 + 0.2 * Math.random())
+          .integerValue();
+
+        checkSendableToEmptyAccount(amount, sibling);
+
+        return {
+          transaction,
+          updates: [{ recipient }, { amount }, { memo: memoTestMessage }],
+        };
+      },
+      test: ({ transaction }: TransactionTestInput<Transaction>): void => {
+        expect(transaction.memo).toBe(memoTestMessage);
+      },
+    },
   ],
 };
 

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

@@ -53,6 +53,7 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
     {
       title: "Memo",
       button: "Rr",
+      expectedValue: ({ transaction }) => transaction.memo as string,
     },
     {
       title: "Confirm",

package/src/families/hedera/transaction.ts

@@ -29,6 +29,7 @@ export function fromTransactionRaw(tr: TransactionRaw): Transaction {
   return {
     ...common,
     family: tr.family,
+    memo: tr.memo,
   };
 }
 
@@ -38,6 +39,7 @@ export function toTransactionRaw(t: Transaction): TransactionRaw {
   return {
     ...common,
     family: t.family,
+    memo: t.memo,
   };
 }
 

package/src/families/hedera/types.ts

@@ -3,11 +3,6 @@ import type {
   TransactionCommonRaw,
 } from "../../types/transaction";
 
-export type CoreStatics = Record<string, never>;
-export type CoreAccountSpecifics = Record<string, never>;
-export type CoreOperationSpecifics = Record<string, never>;
-export type CoreCurrencySpecifics = Record<string, never>;
-
 export type NetworkInfo = {
   family: "hedera";
 };
@@ -18,11 +13,10 @@ export type NetworkInfoRaw = {
 
 export type Transaction = TransactionCommon & {
   family: "hedera";
+  memo?: string;
 };
 
 export type TransactionRaw = TransactionCommonRaw & {
   family: "hedera";
+  memo?: string;
 };
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-export const reflect = (_declare: any) => {};

package/src/families/hedera/utils.ts

@@ -31,7 +31,7 @@ export async function calculateAmount({
 }
 
 // NOTE: convert from the non-url-safe version of base64 to the url-safe version (that the explorer uses)
-export function base64ToUrlSafeBase64(data: string) {
+export function base64ToUrlSafeBase64(data: string): string {
   // Might be nice to use this alternative if .nvmrc changes to >= Node v14.18.0
   // base64url encoding option isn't supported until then
   // Buffer.from(data, "base64").toString("base64url");

package/src/families/solana/react.integration.test.ts

@@ -0,0 +1,76 @@
+import { renderHook } from "@testing-library/react-hooks";
+import { getAccountBridge, getCurrencyBridge } from "../../bridge";
+import { getCryptoCurrencyById } from "../../currencies";
+import { setEnv } from "../../env";
+import { makeBridgeCacheSystem } from "../../bridge/cache";
+import { genAccount, genAddingOperationsInAccount } from "../../mock/account";
+import type { Account, CurrencyBridge } from "../../types";
+import type { Transaction } from "./types";
+import { getCurrentSolanaPreloadData } from "./js-preload-data";
+import { LEDGER_VALIDATOR_ADDRESS } from "./utils";
+import * as hooks from "./react";
+
+const localCache = {};
+const cache = makeBridgeCacheSystem({
+  saveData(c, d) {
+    localCache[c.id] = d;
+    return Promise.resolve();
+  },
+
+  getData(c) {
+    return Promise.resolve(localCache[c.id]);
+  },
+});
+describe("solana/react", () => {
+  describe("useValidators", () => {
+    it("should return validators", async () => {
+      const { prepare, account } = setup();
+      await prepare();
+      const { result } = renderHook(() =>
+        hooks.useValidators(account.currency)
+      );
+      const data = getCurrentSolanaPreloadData(account.currency);
+
+      expect(result.current).toStrictEqual(data.validators);
+    });
+
+    it("should return validators", async () => {
+      const { prepare, account } = setup();
+      await prepare();
+      const { result } = renderHook(() =>
+        hooks.useValidators(account.currency, "Ledger")
+      );
+
+      expect(
+        result.current.some(
+          (validator) => validator.voteAccount === LEDGER_VALIDATOR_ADDRESS
+        )
+      ).toBe(true);
+    });
+  });
+});
+
+function setup(): {
+  account: Account;
+  currencyBridge: CurrencyBridge;
+  transaction: Transaction;
+  prepare: () => Promise<any>;
+} {
+  setEnv("MOCK", 1);
+  setEnv("EXPERIMENTAL_CURRENCIES", "solana");
+  const seed = "solana-2";
+  const currency = getCryptoCurrencyById("solana");
+  const a = genAccount(seed, {
+    currency,
+  });
+  const account = genAddingOperationsInAccount(a, 3, seed);
+  const currencyBridge = getCurrencyBridge(currency);
+  const bridge = getAccountBridge(account);
+  const transaction = bridge.createTransaction(account);
+  return {
+    account,
+    currencyBridge,
+    transaction,
+    prepare: async () => cache.prepareCurrency(currency),
+  };
+}

package/src/families/solana/react.ts

@@ -6,6 +6,7 @@ import {
   getSolanaPreloadData,
 } from "./js-preload-data";
 import { SolanaPreloadDataV1, SolanaStake, SolanaStakeWithMeta } from "./types";
+import { ValidatorsAppValidator } from "./validator-app";
 
 export function useSolanaPreloadData(
   currency: CryptoCurrency
@@ -16,12 +17,36 @@ export function useSolanaPreloadData(
   );
 }
 
-export function useValidators(currency: CryptoCurrency) {
+export function useValidators(
+  currency: CryptoCurrency,
+  search?: string
+): ValidatorsAppValidator[] {
   const data = useSolanaPreloadData(currency);
 
   return useMemo(() => {
-    return data?.validators ?? [];
-  }, [data]);
+    const validators = data?.validators ?? [];
+
+    if (validators.length === 0 || !search || search === "") {
+      return validators;
+    }
+
+    const lowercaseSearch = search.toLowerCase();
+
+    const filtered = validators.filter(
+      (validator) =>
+        validator.name?.toLowerCase().includes(lowercaseSearch) ||
+        validator.voteAccount.toLowerCase().includes(lowercaseSearch)
+    );
+
+    const flags = [];
+    const output: ValidatorsAppValidator[] = [];
+    for (let i = 0; i < filtered.length; i++) {
+      if (flags[filtered[i].voteAccount]) continue;
+      flags[filtered[i].voteAccount] = true;
+      output.push(filtered[i]);
+    }
+    return output;
+  }, [data, search]);
 }
 
 export function useSolanaStakesWithMeta(

package/src/featureFlags/types.ts

@@ -6,6 +6,7 @@ export type FeatureId =
   | "ratings"
   | "counterValue"
   | "buyDeviceFromLive"
+  | "ptxSmartRouting"
   | string;
 
 // We use objects instead of direct booleans for potential future improvements

package/src/generated/deviceTransactionConfig.ts

@@ -2,6 +2,8 @@ import algorand from "../families/algorand/deviceTransactionConfig";
 
 import bitcoin from "../families/bitcoin/deviceTransactionConfig";
 
+import cardano from "../families/cardano/deviceTransactionConfig";
+
 import celo from "../families/celo/deviceTransactionConfig";
 
 import cosmos from "../families/cosmos/deviceTransactionConfig";
@@ -32,6 +34,7 @@ import tron from "../families/tron/deviceTransactionConfig";
 export default {
   algorand,
   bitcoin,
+  cardano,
   celo,
   cosmos,
   crypto_org,