@ledgerhq/live-common 34.48.0-nightly.8 → 34.48.0

package/src/apps/react.ts

@@ -12,12 +12,14 @@ import {
 import { runAppOp } from "./runner";
 import { App } from "@ledgerhq/types-live";
 import { useFeatureFlags } from "../featureFlags";
+import { AppStorageType, StorageProvider } from "../device/use-cases/appDataBackup/types";
 
 type UseAppsRunnerResult = [State, (arg0: Action) => void];
 // use for React apps. support dynamic change of the state.
 export const useAppsRunner = (
   listResult: ListAppsResult,
   exec: Exec,
+  storage: StorageProvider<AppStorageType>,
   appsToRestore?: string[],
 ): UseAppsRunnerResult => {
   // $FlowFixMe for ledger-live-mobile older react/flow version
@@ -34,7 +36,7 @@ export const useAppsRunner = (
 
   useEffect(() => {
     if (appOp) {
-      const sub = runAppOp({ state, appOp, exec }).subscribe(event => {
+      const sub = runAppOp({ state, appOp, exec, storage }).subscribe(event => {
         dispatch({
           type: "onRunnerEvent",
           event,

package/src/apps/runner.ts

@@ -13,15 +13,18 @@ import type { Exec, State, AppOp, RunnerEvent, Action } from "./types";
 import { reducer, getActionPlan, getNextAppOp } from "./logic";
 import { delay } from "../promise";
 import { getEnv } from "@ledgerhq/live-env";
+import { AppStorageType, StorageProvider } from "../device/use-cases/appDataBackup/types";
 
 export const runAppOp = ({
   state,
   appOp,
   exec,
+  storage,
 }: {
   state: State;
   appOp: AppOp;
   exec: Exec;
+  storage?: StorageProvider<AppStorageType>;
 }): Observable<RunnerEvent> => {
   const { appByName, deviceInfo, deviceModel } = state;
   const app = appByName[appOp.name];
@@ -53,6 +56,7 @@ export const runAppOp = ({
         targetId: deviceInfo.targetId,
         app,
         modelId: deviceModel.id,
+        ...(storage ? { storage } : {}),
         ...(state.skipAppDataBackup ? { skipAppDataBackup: true } : {}),
       }),
     ).pipe(
@@ -95,6 +99,7 @@ type InlineInstallProgress = {
 export const runAllWithProgress = (
   state: State,
   exec: Exec,
+  storage?: StorageProvider<AppStorageType>,
   precision = 100,
 ): Observable<InlineInstallProgress> => {
   const total = state.uninstallQueue.length + state.installQueue.length;
@@ -105,7 +110,9 @@ export const runAllWithProgress = (
     return p;
   }
 
-  return concat(...getActionPlan(state).map(appOp => runAppOp({ state, appOp, exec }))).pipe(
+  return concat(
+    ...getActionPlan(state).map(appOp => runAppOp({ state, appOp, exec, storage })),
+  ).pipe(
     map(event => {
       if (event.type === "runError") {
         throw event.error;

package/src/bridge/generic-alpaca/accountBridge.ts

@@ -14,14 +14,9 @@ import { genericEstimateMaxSpendable } from "./estimateMaxSpendable";
 import { createTransaction } from "./createTransaction";
 import { genericBroadcast } from "./broadcast";
 import { genericSignOperation } from "./signOperation";
-import type { AlpacaSigner } from "./signer/types";
 
-export function getAlpacaAccountBridge(
-  network: string,
-  kind: string,
-  customSigner?: AlpacaSigner,
-): AccountBridge<any> {
-  const signer = customSigner ?? getSigner(network);
+export function getAlpacaAccountBridge(network: string, kind: string): AccountBridge<any> {
+  const signer = getSigner(network);
   return {
     sync: makeSync({ getAccountShape: genericGetAccountShape(network, kind) }),
     receive: makeAccountBridgeReceive(getAddressWrapper(signer.getAddress)),
@@ -33,5 +28,5 @@ export function getAlpacaAccountBridge(
     broadcast: genericBroadcast(network, kind),
     signOperation: genericSignOperation(network, kind)(signer.context),
     getSerializedAddressParameters, // NOTE: check wether it should be exposed by coin-module's api instead?
-  } satisfies Partial<AccountBridge<any>>;
+  } satisfies Partial<AccountBridge<any>> as AccountBridge<any>;
 }

package/src/bridge/generic-alpaca/alpaca/index.ts

@@ -2,32 +2,37 @@ import { createApi as createXrpApi } from "@ledgerhq/coin-xrp/api/index";
 import { createApi as createStellarApi } from "@ledgerhq/coin-stellar/api/index";
 import { createApi as createCantonApi } from "@ledgerhq/coin-canton/api/index";
 import { createApi as createTronApi } from "@ledgerhq/coin-tron/api/index";
-import { createApi as createEvmApi } from "@ledgerhq/coin-evm/api/index";
 import { getCurrencyConfiguration } from "../../../config";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getNetworkAlpacaApi } from "./network/network-alpaca";
 import { Api } from "@ledgerhq/coin-framework/api/types";
 import { XrpCoinConfig } from "@ledgerhq/coin-xrp/config";
 import { StellarCoinConfig } from "@ledgerhq/coin-stellar/config";
 import { CantonCoinConfig } from "@ledgerhq/coin-canton/config";
 import { TronCoinConfig } from "@ledgerhq/coin-tron/config";
-import { EvmConfigInfo } from "@ledgerhq/coin-evm/config";
-import { findCryptoCurrencyByNetwork } from "../utils";
 
-export function getAlpacaApi(network: string, kind: string): Api<any> {
+export function getAlpacaApi(network, kind): Api<any> {
   if (kind === "local") {
-    const currency = findCryptoCurrencyByNetwork(network);
-    switch (currency?.family) {
+    switch (network) {
       case "xrp":
-        return createXrpApi(getCurrencyConfiguration<XrpCoinConfig>(currency)) as Api<any>; // FIXME: createXrpApi returns a strongly typed Api<XrpSender>, fix Api<any> to allow it
+        return createXrpApi(
+          getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple")),
+        ) as Api<any>; // FIXME: createXrpApi returns a strongly typed Api<XrpSender>, fix Api<any> to allow it
       case "stellar":
-        return createStellarApi(getCurrencyConfiguration<StellarCoinConfig>(currency)) as Api<any>;
+        return createStellarApi(
+          getCurrencyConfiguration<StellarCoinConfig>(getCryptoCurrencyById("stellar")),
+        ) as Api<any>;
       case "canton":
-        return createCantonApi(getCurrencyConfiguration<CantonCoinConfig>(currency)) as Api<any>;
+        return createCantonApi(
+          getCurrencyConfiguration<CantonCoinConfig>(
+            getCryptoCurrencyById("canton_network_devnet"),
+          ),
+        ) as Api<any>;
       case "tron":
-        return createTronApi(getCurrencyConfiguration<TronCoinConfig>(currency)) as Api<any>;
-      case "evm":
-        return createEvmApi(getCurrencyConfiguration<EvmConfigInfo>(currency), network) as Api<any>;
+        return createTronApi(
+          getCurrencyConfiguration<TronCoinConfig>(getCryptoCurrencyById("tron")),
+        ) as Api<any>;
     }
   }
-  return getNetworkAlpacaApi(network) satisfies Partial<Api<any>>;
+  return getNetworkAlpacaApi(network) satisfies Partial<Api<any>> as Api<any>;
 }

package/src/bridge/generic-alpaca/alpaca/index.unit.test.ts

@@ -3,7 +3,6 @@ import * as xrpModule from "@ledgerhq/coin-xrp/api/index";
 import * as stellarModule from "@ledgerhq/coin-stellar/api/index";
 import * as cantonModule from "@ledgerhq/coin-canton/api/index";
 import * as tronModule from "@ledgerhq/coin-tron/api/index";
-import * as evmModule from "@ledgerhq/coin-evm/api/index";
 import * as config from "../../../config";
 import * as networkApi from "./network/network-alpaca";
 import * as cryptoAssets from "@ledgerhq/cryptoassets/currencies";
@@ -11,7 +10,7 @@ import * as cryptoAssets from "@ledgerhq/cryptoassets/currencies";
 const mockApiInstance = { mock: "api" };
 
 jest.mock("@ledgerhq/cryptoassets/currencies", () => ({
-  findCryptoCurrencyById: jest.fn(),
+  getCryptoCurrencyById: jest.fn(),
 }));
 
 jest.mock("../../../config", () => ({
@@ -34,37 +33,18 @@ jest.mock("@ledgerhq/coin-tron/api/index", () => ({
   createApi: jest.fn(),
 }));
 
-jest.mock("@ledgerhq/coin-evm/api/index", () => ({
-  createApi: jest.fn(),
-}));
-
 jest.mock("./network/network-alpaca", () => ({
   getNetworkAlpacaApi: jest.fn(),
 }));
 
 describe("getAlpacaApi", () => {
+  const mockCurrency = { id: "mock-currency" };
+
   beforeEach(() => {
     jest.clearAllMocks();
 
     // Common mocks
-    (cryptoAssets.findCryptoCurrencyById as jest.Mock).mockImplementation(id => {
-      switch (id) {
-        case "ripple":
-          return { family: "xrp" };
-        case "stellar":
-          return { family: "stellar" };
-        case "canton":
-          return { family: "canton" };
-        case "tron":
-          return { family: "tron" };
-        case "ethereum":
-          return { family: "evm" };
-        case "sonic":
-          return { family: "evm" };
-        default:
-          return undefined;
-      }
-    });
+    (cryptoAssets.getCryptoCurrencyById as jest.Mock).mockReturnValue(mockCurrency);
     (config.getCurrencyConfiguration as jest.Mock).mockReturnValue({ config: true });
 
     // API mocks
@@ -72,29 +52,21 @@ describe("getAlpacaApi", () => {
     jest.spyOn(stellarModule, "createApi").mockReturnValue(mockApiInstance as any);
     jest.spyOn(cantonModule, "createApi").mockReturnValue(mockApiInstance as any);
     jest.spyOn(tronModule, "createApi").mockReturnValue(mockApiInstance as any);
-    jest.spyOn(evmModule, "createApi").mockReturnValue(mockApiInstance as any);
     jest.spyOn(networkApi, "getNetworkAlpacaApi").mockReturnValue(mockApiInstance as any);
   });
 
   const testCases = [
-    { network: "xrp", module: xrpModule, label: "XRP", params: [{ config: true }] },
-    { network: "stellar", module: stellarModule, label: "Stellar", params: [{ config: true }] },
-    { network: "tron", module: tronModule, label: "Tron", params: [{ config: true }] },
-    { network: "canton", module: cantonModule, label: "Canton", params: [{ config: true }] },
-    {
-      network: "ethereum",
-      module: evmModule,
-      label: "Ethereum",
-      params: [{ config: true }, "ethereum"],
-    },
-    { network: "sonic", module: evmModule, label: "Sonic", params: [{ config: true }, "sonic"] },
+    { network: "xrp", module: xrpModule, label: "XRP" },
+    { network: "stellar", module: stellarModule, label: "Stellar" },
+    { network: "tron", module: tronModule, label: "Tron" },
+    { network: "canton", module: cantonModule, label: "Canton" },
   ];
 
-  testCases.forEach(({ network, module, label, params }) => {
+  testCases.forEach(({ network, module, label }) => {
     it(`should return ${label} API for network "${network}" and kind "local"`, () => {
       const result = getAlpacaApi(network, "local");
       expect(result).toEqual(mockApiInstance);
-      expect(module.createApi).toHaveBeenCalledWith(...params);
+      expect(module.createApi).toHaveBeenCalledWith({ config: true });
     });
   });
 

package/src/bridge/generic-alpaca/createTransaction.ts

@@ -19,7 +19,7 @@ export function createTransaction(account: Account | TokenAccount): TransactionC
   feeCustomUnit?: Unit | null | undefined;
   memoType?: string | null;
   memoValue?: string | null;
-  mode?: "send" | "changeTrust" | "send-legacy" | "send-eip1559";
+  mode?: "send" | "changeTrust";
   assetReference?: string;
   assetOwner?: string;
   networkInfo?: NetworkInfo | null;
@@ -51,14 +51,6 @@ export function createTransaction(account: Account | TokenAccount): TransactionC
         assetOwner: "",
         networkInfo: null,
       };
-    case "evm": {
-      return {
-        mode: "send-eip1559",
-        family: currency.family,
-        amount: new BigNumber(0),
-        recipient: "",
-      };
-    }
     default:
       throw new Error(`Unsupported currency family: ${currency.family}`);
   }

package/src/bridge/generic-alpaca/currencyBridge.ts

@@ -2,14 +2,8 @@ import { makeScanAccounts } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { CurrencyBridge } from "@ledgerhq/types-live";
 import { genericGetAccountShape } from "./getAccountShape";
 import { getSigner } from "./signer";
-import type { AlpacaSigner } from "./signer/types";
 
-export function getAlpacaCurrencyBridge(
-  network: string,
-  kind: string,
-  customSigner?: AlpacaSigner,
-): CurrencyBridge {
-  const signer = customSigner ?? getSigner(network);
+export function getAlpacaCurrencyBridge(network: string, kind: string): CurrencyBridge {
   return {
     preload: () => Promise.resolve({}),
     hydrate: () => {
@@ -17,7 +11,7 @@ export function getAlpacaCurrencyBridge(
     },
     scanAccounts: makeScanAccounts({
       getAccountShape: genericGetAccountShape(network, kind),
-      getAddressFn: signer.getAddress.bind(signer),
+      getAddressFn: getSigner(network).getAddress,
     }),
   };
 }

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -73,7 +73,7 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
         getTokenFromAsset: alpacaApi.getTokenFromAsset,
       }) || [];
 
-    const operations = mergedOps.map(op => {
+    const operationsWithSubs = mergedOps.map(op => {
       const subOperations = inferSubOperations(op.hash, subAccounts);
 
       return {
@@ -85,12 +85,13 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
     const res = {
       id: accountId,
       xpub: address,
-      blockHeight: operations.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
+      blockHeight:
+        operationsWithSubs.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
       balance: new BigNumber(nativeBalance.toString()),
       spendableBalance: new BigNumber(spendableBalance.toString()),
-      operations,
+      operations: operationsWithSubs,
       subAccounts,
-      operationsCount: operations.length,
+      operationsCount: operationsWithSubs.length,
     };
     return res;
   };

package/src/bridge/generic-alpaca/signer/index.ts

@@ -1,12 +1,22 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
 import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
-import Stellar from "@ledgerhq/hw-app-str";
-import { signTransaction, stellarSignTransaction } from "./signTransaction";
-import { StrKey } from "@stellar/stellar-sdk";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
+import Stellar from "@ledgerhq/hw-app-str";
+
 import Transport from "@ledgerhq/hw-transport";
-import { AlpacaSigner } from "./types";
+import { signTransaction, stellarSignTransaction } from "./signTransaction";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { SignTransactionOptions } from "./types";
+import { StrKey } from "@stellar/stellar-sdk";
+
+export type AlpacaSigner = {
+  getAddress: GetAddressFn;
+  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
+  signMessage?: (message: string) => Promise<string>;
+  context: SignerContext<any>;
+};
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -37,7 +47,7 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
-export function getSigner(network: string): AlpacaSigner {
+export function getSigner(network): AlpacaSigner {
   switch (network) {
     case "ripple":
     case "xrp": {

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -1,10 +1,9 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { XrpSigner } from "@ledgerhq/coin-xrp/index";
+import { SignTransactionOptions } from "./types";
 import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
-import { LegacySigner, SignTransactionOptions } from "./types";
 
-export const signTransaction = <Signer extends LegacySigner>(
-  signerContext: SignerContext<Signer>,
-) => {
+export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
   return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
     const signedTx = await signerContext(deviceId, signer =>
       signer.signTransaction(path, rawTxHex),

package/src/bridge/generic-alpaca/signer/types.ts

@@ -1,17 +1,3 @@
-import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-
-export type LegacySigner = {
-  signTransaction: (path: string, rawTxHex: string) => Promise<string>;
-};
-
-export type AlpacaSigner<S = unknown> = {
-  getAddress: GetAddressFn;
-  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
-  signMessage?: (message: string) => Promise<string>;
-  context: SignerContext<S>;
-};
-
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;

package/src/bridge/generic-alpaca/utils.test.ts

@@ -1,36 +1,8 @@
-import {
-  adaptCoreOperationToLiveOperation,
-  extractBalance,
-  findCryptoCurrencyByNetwork,
-} from "./utils";
+import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
 import BigNumber from "bignumber.js";
 import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
 
 describe("Alpaca utils", () => {
-  describe("findCryptoCurrencyByNetwork", () => {
-    it("finds a crypto currency by id", () => {
-      expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({
-        id: "ethereum",
-        family: "evm",
-      });
-    });
-
-    it("takes currency remapping into account", () => {
-      expect(findCryptoCurrencyByNetwork("ripple")).toMatchObject({
-        id: "ripple",
-        family: "xrp",
-      });
-      expect(findCryptoCurrencyByNetwork("xrp")).toMatchObject({
-        id: "ripple",
-        family: "xrp",
-      });
-    });
-
-    it("does not find non existing currencies", () => {
-      expect(findCryptoCurrencyByNetwork("non_existing_currency")).toBeUndefined();
-    });
-  });
-
   describe("extractBalance", () => {
     it("extracts an existing balance", () => {
       expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({

package/src/bridge/generic-alpaca/utils.ts

@@ -7,15 +7,6 @@ import {
   Operation as CoreOperation,
   TransactionIntent,
 } from "@ledgerhq/coin-framework/api/types";
-import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-export function findCryptoCurrencyByNetwork(network: string): CryptoCurrency | undefined {
-  const networksRemap = {
-    xrp: "ripple",
-  };
-  return findCryptoCurrencyById(networksRemap[network] ?? network);
-}
 
 export function extractBalance(balances: Balance[], type: string): Balance {
   return (
@@ -119,12 +110,6 @@ export function transactionToIntent(
       case "send":
         transactionType = "send";
         break;
-      case "send-legacy":
-        transactionType = "send-legacy";
-        break;
-      case "send-eip1559":
-        transactionType = "send-eip1559";
-        break;
       default:
         throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
     }

package/src/config/sharedConfig.ts

@@ -11,7 +11,6 @@ import { evmConfig } from "../families/evm/config";
 import { fileCoinConfig } from "../families/filecoin/config";
 import { hederaConfig } from "../families/hedera/config";
 import { internetComputerConfig } from "../families/internet_computer/config";
-import { kaspaConfig } from "../families/kaspa/config";
 import { nearConfig } from "../families/near/config";
 import { minaConfig } from "../families/mina/config";
 import { polkadotConfig } from "../families/polkadot/config";
@@ -56,7 +55,6 @@ export const liveConfig: ConfigSchema = {
   ...fileCoinConfig,
   ...hederaConfig,
   ...internetComputerConfig,
-  ...kaspaConfig,
   ...nearConfig,
   ...minaConfig,
   ...polkadotConfig,

package/src/e2e/enum/Account.ts

@@ -276,20 +276,6 @@ export class Account {
     0,
   );
 
-  static readonly KASPA_1 = new Account(
-    Currency.KAS,
-    "KASPA 1",
-    "kaspa:kaspa:qqpqtujclz2usyj7rgmhghfu8e5echrh8t2pkz69tq37uclfrpu3g0w6laqqk",
-    0,
-  );
-
-  static readonly KASPA_2 = new Account(
-    Currency.KAS,
-    "KASPA 2",
-    "kaspa:qrx2agwk93qyjvlcuzz5jy37knt298zupvw2ls05p4te55c29uwuyzzra5qkv",
-    1,
-  );
-
   static readonly LTC_1 = new Account(
     Currency.LTC,
     "Litecoin 1",

package/src/e2e/enum/AppInfos.ts

@@ -60,6 +60,4 @@ export class AppInfos {
   static readonly CELO = new AppInfos("Celo");
 
   static readonly LTC = new AppInfos("Litecoin");
-
-  static readonly KASPA = new AppInfos("Kaspa");
 }

package/src/e2e/enum/Currency.ts

@@ -25,8 +25,6 @@ export class Currency {
 
   static readonly APT = new Currency("Aptos", "APT", "aptos", AppInfos.APTOS, [Network.APTOS]);
 
-  static readonly KAS = new Currency("Kaspa", "KAS", "kaspa", AppInfos.KASPA, [Network.KASPA]);
-
   static readonly tBTC = new Currency(
     "Bitcoin Testnet",
     "𝚝BTC",

package/src/e2e/enum/Network.ts

@@ -30,5 +30,4 @@ export enum Network {
   OSMOSIS = "Osmosis",
   MULTIVERS_X = "MultiversX",
   LITECOIN = "Litecoin",
-  KASPA = "Kaspa",
 }

package/src/e2e/speculos.ts

@@ -30,7 +30,6 @@ import { sendXRP } from "./families/xrp";
 import { delegateAptos, sendAptos } from "./families/aptos";
 import { delegateNear } from "./families/near";
 import { delegateCosmos, sendCosmos } from "./families/cosmos";
-import { sendKaspa } from "./families/kaspa";
 import { delegateSolana, sendSolana } from "./families/solana";
 import { delegateTezos } from "./families/tezos";
 import { delegateCelo } from "./families/celo";
@@ -326,14 +325,6 @@ export const specs: Specs = {
     },
     dependency: "",
   },
-  Kaspa: {
-    currency: getCryptoCurrencyById("kaspa"),
-    appQuery: {
-      model: getSpeculosModel(),
-      appName: "Kaspa",
-    },
-    dependency: "",
-  },
 };
 
 export async function startSpeculos(
@@ -686,9 +677,6 @@ export async function signSendTransaction(tx: Transaction) {
     case Currency.APT:
       await sendAptos();
       break;
-    case Currency.KAS:
-      await sendKaspa();
-      break;
     default:
       throw new Error(`Unsupported currency: ${currencyName.ticker}`);
   }