@ledgerhq/live-common 34.35.1-hotfix.0 → 34.36.0-next.0

package/src/e2e/speculosCI.ts

@@ -0,0 +1,161 @@
+import axios from "axios";
+import {
+  conventionalAppSubpath,
+  DeviceParams,
+  reverseModelMap,
+} from "@ledgerhq/speculos-transport";
+import { SpeculosDevice } from "./speculos";
+import https from "https";
+
+const { SEED, GITHUB_TOKEN, AWS_ROLE, CLUSTER } = process.env;
+const GIT_API_URL = "https://api.github.com/repos/LedgerHQ/actions/actions/";
+const START_WORKFLOW_ID = "workflows/161487603/dispatches";
+const STOP_WORKFLOW_ID = "workflows/161487604/dispatches";
+const GITHUB_REF = "main";
+const getSpeculosAddress = (runId: string) => `https://${runId}.speculos.aws.stg.ldg-tech.com`;
+const speculosPort = 443;
+
+function uniqueId(): string {
+  const timestamp = Date.now().toString(36);
+  const randomString = Math.random().toString(36).slice(2, 7);
+  return timestamp + randomString;
+}
+
+/**
+ * Helper function to make API requests with error handling
+ */
+async function githubApiRequest<T = unknown>({
+  method = "POST",
+  urlSuffix,
+  data,
+  params,
+}: {
+  method?: "GET" | "POST";
+  urlSuffix: string;
+  data?: Record<string, unknown>;
+  params?: Record<string, unknown>;
+}): Promise<T> {
+  const url = `${GIT_API_URL}${urlSuffix}`;
+  try {
+    const response = await axios({
+      method,
+      url,
+      headers: {
+        Authorization: `Bearer ${GITHUB_TOKEN}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+      data,
+      params,
+    });
+    return response.data;
+  } catch (error) {
+    console.warn(
+      `API Request failed: ${method} ${url}`,
+      axios.isAxiosError(error) ? error.response?.data : (error as Error).message,
+    );
+    throw error;
+  }
+}
+
+function waitForSpeculosReady(url: string, { interval = 2000, timeout = 120_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+
+    function check() {
+      https
+        .get(url, res => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+            process.env.SPECULOS_ADDRESS = url;
+            resolve(true);
+          } else {
+            retry();
+          }
+        })
+        .on("error", retry);
+    }
+
+    function retry() {
+      if (Date.now() - startTime >= timeout) {
+        reject(new Error(`Timeout: ${url} did not become available within ${timeout}ms`));
+      } else {
+        setTimeout(check, interval);
+      }
+    }
+
+    check();
+  });
+}
+
+function createStartPayload(deviceParams: DeviceParams, runId: string) {
+  const { model, firmware, appName, appVersion, dependency, dependencies } = deviceParams;
+
+  let additional_args = "-p";
+
+  if (dependency) {
+    additional_args = `${additional_args} -l ${dependency}:/apps/${conventionalAppSubpath(model, firmware, dependency, appVersion)}`;
+  } else if (dependencies) {
+    additional_args = [
+      ...new Set(
+        dependencies.map(
+          dep =>
+            `${additional_args} -l ${dep.name}:/apps/${conventionalAppSubpath(
+              model,
+              firmware,
+              dep.name,
+              dep.appVersion ?? "1.0.0",
+            )}`,
+        ),
+      ),
+    ].join(" ");
+  }
+
+  return {
+    ref: GITHUB_REF,
+    inputs: {
+      coin_app: appName,
+      coin_app_version: appVersion,
+      device: reverseModelMap[model],
+      device_os_version: firmware,
+      aws_role: AWS_ROLE,
+      cluster: CLUSTER,
+      seed: SEED,
+      run_id: runId,
+      additional_args,
+    },
+  };
+}
+
+export async function createSpeculosDeviceCI(
+  deviceParams: DeviceParams,
+): Promise<SpeculosDevice | undefined> {
+  try {
+    const runId = uniqueId();
+    console.warn("Creating remote speculos:", runId);
+    const data = createStartPayload(deviceParams, runId);
+    await githubApiRequest({ urlSuffix: START_WORKFLOW_ID, data });
+    await waitForSpeculosReady(getSpeculosAddress(runId));
+
+    return {
+      id: runId,
+      port: speculosPort,
+    };
+  } catch (e: unknown) {
+    console.error(e);
+    console.warn(
+      `Creating remote speculos ${deviceParams.appName}:${deviceParams.appVersion} failed with ${String(e)}`,
+    );
+  }
+}
+
+export async function releaseSpeculosDeviceCI(runId: string) {
+  const data = {
+    ref: GITHUB_REF,
+    inputs: {
+      run_id: runId.toString(),
+      aws_role: AWS_ROLE,
+      cluster: CLUSTER,
+    },
+  };
+  await githubApiRequest({ urlSuffix: STOP_WORKFLOW_ID, data });
+}

package/src/families/hedera/logic.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-hedera/logic";

package/src/featureFlags/defaultFeatures.ts

@@ -617,6 +617,7 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
   ldmkConnectApp: DEFAULT_FEATURE,
+  lldNetworkBasedAddAccount: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/hw/actions/manager.ts

@@ -24,7 +24,7 @@ type State = {
   isLocked: boolean;
 };
 
-type ManagerState = State & {
+export type ManagerState = State & {
   repairModalOpened:
     | {
         auto: boolean;

package/src/hw/connectApp.ts

@@ -26,10 +26,18 @@ import getDeviceInfo from "./getDeviceInfo";
 import getAddress from "./getAddress";
 import openApp from "./openApp";
 import quitApp from "./quitApp";
-import { mustUpgrade } from "../apps";
+import { mustUpgrade, getMinVersion } from "../apps";
 import isUpdateAvailable from "./isUpdateAvailable";
 import { LockedDeviceEvent } from "./actions/types";
 import { getLatestFirmwareForDeviceUseCase } from "../device/use-cases/getLatestFirmwareForDeviceUseCase";
+import {
+  type ApplicationDependency,
+  type ApplicationConstraint,
+  type ApplicationVersionConstraint,
+  type DeviceManagementKit,
+} from "@ledgerhq/device-management-kit";
+import { ConnectAppDeviceAction } from "@ledgerhq/live-dmk-shared";
+import { ConnectAppEventMapper } from "./connectAppEventMapper";
 
 export type RequiresDerivation = {
   currencyId: string;
@@ -274,7 +282,7 @@ const derivationLogic = (
  * @param allowPartialDependencies If some dependencies need to be installed, and if set to true,
  *   skip any app install if the app is not found from the provider.
  */
-const cmd = ({ deviceId, request }: Input): Observable<ConnectAppEvent> => {
+const cmd = (transport: Transport, { request }: Input): Observable<ConnectAppEvent> => {
   const {
     appName,
     requiresDerivation,
@@ -283,202 +291,222 @@ const cmd = ({ deviceId, request }: Input): Observable<ConnectAppEvent> => {
     outdatedApp,
     allowPartialDependencies = false,
   } = request;
-  return withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        const timeoutSub = of({
-          type: "unresponsiveDevice",
-        })
-          .pipe(delay(1000))
-          .subscribe(e => o.next(e as ConnectAppEvent));
-        const innerSub = ({
-          appName,
-          dependencies,
-          requireLatestFirmware,
-        }: ConnectAppRequest): Observable<ConnectAppEvent> =>
-          defer(() => from(getAppAndVersion(transport))).pipe(
-            concatMap((appAndVersion): Observable<ConnectAppEvent> => {
-              timeoutSub.unsubscribe();
+  return new Observable(o => {
+    const timeoutSub = of({
+      type: "unresponsiveDevice",
+    })
+      .pipe(delay(1000))
+      .subscribe(e => o.next(e as ConnectAppEvent));
+    const innerSub = ({
+      appName,
+      dependencies,
+      requireLatestFirmware,
+    }: ConnectAppRequest): Observable<ConnectAppEvent> =>
+      defer(() => from(getAppAndVersion(transport))).pipe(
+        concatMap((appAndVersion): Observable<ConnectAppEvent> => {
+          timeoutSub.unsubscribe();
 
-              if (isDashboardName(appAndVersion.name)) {
-                // check if we meet minimum fw
-                if (requireLatestFirmware || outdatedApp) {
-                  return from(getDeviceInfo(transport)).pipe(
-                    mergeMap((deviceInfo: DeviceInfo) =>
-                      from(getLatestFirmwareForDeviceUseCase(deviceInfo)).pipe(
-                        mergeMap((latest: FirmwareUpdateContext | undefined | null) => {
-                          const isLatest =
-                            !latest || semver.eq(deviceInfo.version, latest.final.version);
+          if (isDashboardName(appAndVersion.name)) {
+            // check if we meet minimum fw
+            if (requireLatestFirmware || outdatedApp) {
+              return from(getDeviceInfo(transport)).pipe(
+                mergeMap((deviceInfo: DeviceInfo) =>
+                  from(getLatestFirmwareForDeviceUseCase(deviceInfo)).pipe(
+                    mergeMap((latest: FirmwareUpdateContext | undefined | null) => {
+                      const isLatest =
+                        !latest || semver.eq(deviceInfo.version, latest.final.version);
 
-                          if (
-                            (!requireLatestFirmware || (requireLatestFirmware && isLatest)) &&
-                            outdatedApp
-                          ) {
-                            return from(isUpdateAvailable(deviceInfo, outdatedApp)).pipe(
-                              mergeMap(isAvailable =>
-                                isAvailable
-                                  ? throwError(
-                                      () =>
-                                        new UpdateYourApp(undefined, {
-                                          managerAppName: outdatedApp.name,
-                                        }),
-                                    )
-                                  : throwError(
-                                      () =>
-                                        new LatestFirmwareVersionRequired(
-                                          "LatestFirmwareVersionRequired",
-                                          {
-                                            latest: latest?.final.version,
-                                            current: deviceInfo.version,
-                                          },
-                                        ),
+                      if (
+                        (!requireLatestFirmware || (requireLatestFirmware && isLatest)) &&
+                        outdatedApp
+                      ) {
+                        return from(isUpdateAvailable(deviceInfo, outdatedApp)).pipe(
+                          mergeMap(isAvailable =>
+                            isAvailable
+                              ? throwError(
+                                  () =>
+                                    new UpdateYourApp(undefined, {
+                                      managerAppName: outdatedApp.name,
+                                    }),
+                                )
+                              : throwError(
+                                  () =>
+                                    new LatestFirmwareVersionRequired(
+                                      "LatestFirmwareVersionRequired",
+                                      {
+                                        latest: latest?.final.version,
+                                        current: deviceInfo.version,
+                                      },
                                     ),
-                              ),
-                            );
-                          }
+                                ),
+                          ),
+                        );
+                      }
 
-                          if (isLatest) {
-                            o.next({ type: "latest-firmware-resolved" });
-                            return innerSub({
-                              appName,
-                              dependencies,
-                              allowPartialDependencies,
-                              // requireLatestFirmware // Resolved!.
-                            });
-                          } else {
-                            return throwError(
-                              () =>
-                                new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired", {
-                                  latest: latest.final.version,
-                                  current: deviceInfo.version,
-                                }),
-                            );
-                          }
-                        }),
-                      ),
-                    ),
-                  );
-                }
-                // check if we meet dependencies
-                if (dependencies?.length) {
-                  const completesInDashboard = isDashboardName(appName);
-                  return inlineAppInstall({
-                    transport,
-                    appNames: [...(completesInDashboard ? [] : [appName]), ...dependencies],
-                    onSuccessObs: () => {
-                      o.next({
-                        type: "dependencies-resolved",
-                      });
-                      return innerSub({
-                        appName,
-                        allowPartialDependencies,
-                        // dependencies // Resolved!
-                      });
-                    },
+                      if (isLatest) {
+                        o.next({ type: "latest-firmware-resolved" });
+                        return innerSub({
+                          appName,
+                          dependencies,
+                          allowPartialDependencies,
+                          // requireLatestFirmware // Resolved!.
+                        });
+                      } else {
+                        return throwError(
+                          () =>
+                            new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired", {
+                              latest: latest.final.version,
+                              current: deviceInfo.version,
+                            }),
+                        );
+                      }
+                    }),
+                  ),
+                ),
+              );
+            }
+            // check if we meet dependencies
+            if (dependencies?.length) {
+              const completesInDashboard = isDashboardName(appName);
+              return inlineAppInstall({
+                transport,
+                appNames: [...(completesInDashboard ? [] : [appName]), ...dependencies],
+                onSuccessObs: () => {
+                  o.next({
+                    type: "dependencies-resolved",
+                  });
+                  return innerSub({
+                    appName,
                     allowPartialDependencies,
+                    // dependencies // Resolved!
                   });
-                }
+                },
+                allowPartialDependencies,
+              });
+            }
 
-                // maybe we want to be in the dashboard
-                if (appName === appAndVersion.name) {
-                  const e: ConnectAppEvent = {
-                    type: "opened",
-                    app: appAndVersion,
-                  };
-                  return of(e);
-                }
+            // maybe we want to be in the dashboard
+            if (appName === appAndVersion.name) {
+              const e: ConnectAppEvent = {
+                type: "opened",
+                app: appAndVersion,
+              };
+              return of(e);
+            }
 
-                // we're in dashboard
-                return openAppFromDashboard(transport, appName);
-              }
+            // we're in dashboard
+            return openAppFromDashboard(transport, appName);
+          }
 
-              const appNeedsUpgrade = mustUpgrade(appAndVersion.name, appAndVersion.version);
-              if (appNeedsUpgrade) {
-                // quit app, check provider's app update for device's minimum requirements.
-                o.next({
-                  type: "has-outdated-app",
-                  outdatedApp: appAndVersion,
-                });
-              }
+          const appNeedsUpgrade = mustUpgrade(appAndVersion.name, appAndVersion.version);
+          if (appNeedsUpgrade) {
+            // quit app, check provider's app update for device's minimum requirements.
+            o.next({
+              type: "has-outdated-app",
+              outdatedApp: appAndVersion,
+            });
+          }
 
-              // need dashboard to check firmware, install dependencies, or verify app update
-              if (
-                dependencies?.length ||
-                requireLatestFirmware ||
-                appAndVersion.name !== appName ||
-                appNeedsUpgrade
-              ) {
-                return attemptToQuitApp(transport, appAndVersion as AppAndVersion);
-              }
+          // need dashboard to check firmware, install dependencies, or verify app update
+          if (
+            dependencies?.length ||
+            requireLatestFirmware ||
+            appAndVersion.name !== appName ||
+            appNeedsUpgrade
+          ) {
+            return attemptToQuitApp(transport, appAndVersion as AppAndVersion);
+          }
+
+          if (requiresDerivation) {
+            return derivationLogic(transport, {
+              requiresDerivation,
+              appAndVersion: appAndVersion as AppAndVersion,
+              appName,
+            });
+          } else {
+            const e: ConnectAppEvent = {
+              type: "opened",
+              app: appAndVersion,
+            };
+            return of(e);
+          }
+        }),
+        catchError((e: unknown) => {
+          if (
+            (typeof e === "object" &&
+              e !== null &&
+              "_tag" in e &&
+              e._tag === "DeviceDisconnectedWhileSendingError") ||
+            e instanceof DisconnectedDeviceDuringOperation ||
+            e instanceof DisconnectedDevice
+          ) {
+            return of(<ConnectAppEvent>{
+              type: "disconnected",
+            });
+          }
+
+          if (e && e instanceof TransportStatusError) {
+            switch (e.statusCode) {
+              case StatusCodes.CLA_NOT_SUPPORTED: // in 1.3.1 dashboard
+              case StatusCodes.INS_NOT_SUPPORTED: // in 1.3.1 and bitcoin app
+                // fallback on "old way" because device does not support getAppAndVersion
+                if (!requiresDerivation) {
+                  // if there is no derivation, there is nothing we can do to check an app (e.g. requiring non coin app)
+                  return throwError(() => new FirmwareOrAppUpdateRequired());
+                }
 
-              if (requiresDerivation) {
                 return derivationLogic(transport, {
                   requiresDerivation,
-                  appAndVersion: appAndVersion as AppAndVersion,
                   appName,
                 });
-              } else {
-                const e: ConnectAppEvent = {
-                  type: "opened",
-                  app: appAndVersion,
-                };
-                return of(e);
-              }
-            }),
-            catchError((e: unknown) => {
-              if (
-                (typeof e === "object" &&
-                  e !== null &&
-                  "_tag" in e &&
-                  e._tag === "DeviceDisconnectedWhileSendingError") ||
-                e instanceof DisconnectedDeviceDuringOperation ||
-                e instanceof DisconnectedDevice
-              ) {
-                return of(<ConnectAppEvent>{
-                  type: "disconnected",
-                });
-              }
+            }
+          } else if (e instanceof LockedDeviceError) {
+            return of({
+              type: "lockedDevice",
+            } as ConnectAppEvent);
+          }
 
-              if (e && e instanceof TransportStatusError) {
-                switch (e.statusCode) {
-                  case StatusCodes.CLA_NOT_SUPPORTED: // in 1.3.1 dashboard
-                  case StatusCodes.INS_NOT_SUPPORTED: // in 1.3.1 and bitcoin app
-                    // fallback on "old way" because device does not support getAppAndVersion
-                    if (!requiresDerivation) {
-                      // if there is no derivation, there is nothing we can do to check an app (e.g. requiring non coin app)
-                      return throwError(() => new FirmwareOrAppUpdateRequired());
-                    }
+          return throwError(() => e);
+        }),
+      );
 
-                    return derivationLogic(transport, {
-                      requiresDerivation,
-                      appName,
-                    });
-                }
-              } else if (e instanceof LockedDeviceError) {
-                return of({
-                  type: "lockedDevice",
-                } as ConnectAppEvent);
-              }
+    const sub = innerSub({
+      appName,
+      dependencies,
+      requireLatestFirmware,
+      allowPartialDependencies,
+    }).subscribe(o);
 
-              return throwError(() => e);
-            }),
-          );
-
-        const sub = innerSub({
-          appName,
-          dependencies,
-          requireLatestFirmware,
-          allowPartialDependencies,
-        }).subscribe(o);
+    return () => {
+      timeoutSub.unsubscribe();
+      sub.unsubscribe();
+    };
+  });
+};
 
-        return () => {
-          timeoutSub.unsubscribe();
-          sub.unsubscribe();
-        };
-      }),
+const isDmkTransport = (
+  transport: Transport,
+): transport is Transport & { dmk: DeviceManagementKit; sessionId: string } => {
+  return (
+    "dmk" in transport &&
+    transport.dmk !== undefined &&
+    "sessionId" in transport &&
+    transport.sessionId !== undefined
   );
 };
 
+const appNameToDependency = (appName: string): ApplicationDependency => {
+  let constraints: ApplicationConstraint[] | undefined = undefined;
+  const minVersion = getMinVersion(appName);
+  if (minVersion !== undefined) {
+    constraints = [{ minVersion: minVersion as ApplicationVersionConstraint }];
+  }
+  return {
+    name: appName,
+    constraints,
+  };
+};
+
 export default function connectAppFactory(
   {
     isLdmkConnectAppEnabled,
@@ -487,7 +515,46 @@ export default function connectAppFactory(
   } = { isLdmkConnectAppEnabled: false },
 ) {
   if (!isLdmkConnectAppEnabled) {
-    return cmd;
+    return ({ deviceId, request }: Input): Observable<ConnectAppEvent> =>
+      withDevice(deviceId)(transport => cmd(transport, { deviceId, request }));
   }
-  throw new Error("LdkmConnectApp is not supported yet");
+  return ({ deviceId, request }: Input): Observable<ConnectAppEvent> => {
+    const {
+      appName,
+      requiresDerivation,
+      dependencies,
+      requireLatestFirmware,
+      allowPartialDependencies = false,
+    } = request;
+    return withDevice(deviceId)(transport => {
+      if (!isDmkTransport(transport)) {
+        return cmd(transport, { deviceId, request });
+      }
+      const { dmk, sessionId } = transport;
+      const deviceAction = new ConnectAppDeviceAction({
+        input: {
+          application: appNameToDependency(appName),
+          dependencies: dependencies ? dependencies.map(name => ({ name })) : [],
+          requireLatestFirmware,
+          allowMissingApplication: allowPartialDependencies,
+          unlockTimeout: 0, // Expect to fail immediately when device is locked
+          requiredDerivation: requiresDerivation
+            ? async () => {
+                const { currencyId, ...derivationRest } = requiresDerivation;
+                const derivation = await getAddress(transport, {
+                  currency: getCryptoCurrencyById(currencyId),
+                  ...derivationRest,
+                });
+                return derivation.address;
+              }
+            : undefined,
+        },
+      });
+      const observable = dmk.executeDeviceAction({
+        sessionId,
+        deviceAction,
+      });
+      return new ConnectAppEventMapper(dmk, sessionId, appName, observable).map();
+    });
+  };
 }