@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/libcore/platforms/react-native.ts

@@ -1,242 +0,0 @@
-import { NotEnoughBalance, NetworkDown } from "@ledgerhq/errors";
-import type { Core, CoreStatics, Spec } from "../types";
-import { reflect } from "../types";
-import { setLoadCoreImplementation } from "../access";
-import { setRemapLibcoreErrorsImplementation } from "../errors";
-
-export default (arg: { getNativeModule: (id: string) => any }): void => {
-  const { getNativeModule } = arg;
-
-  async function loadCore(): Promise<Core> {
-    // Abstract out the libcore interface into a higher level API.
-    const mappings: CoreStatics | Record<string, any> = {};
-    const wrappers = {
-      // FIXME need to fix it in RN bindings
-      hex: (value) => value.replace(/[< >]/g, ""),
-    };
-
-    function wrap(id, ref) {
-      if (!ref) return ref;
-
-      if (Array.isArray(id)) {
-        const [actualId] = id;
-        return ref.map((r) => wrap(actualId, r));
-      }
-
-      if (id in wrappers) {
-        return wrappers[id](ref);
-      }
-
-      const Clz = mappings[id];
-
-      if (!Clz) {
-        console.warn(`Unknown wrapping '${id}'`);
-        return ref;
-      }
-
-      return new Clz(ref);
-    }
-
-    function unwrap(id, instance, ctx) {
-      if (!instance) return instance;
-
-      if (Array.isArray(id)) {
-        const [actualId] = id;
-        return instance.map((inst) => unwrap(actualId, inst, undefined));
-      }
-
-      const Clz = mappings[id];
-
-      if (!Clz) {
-        return instance;
-      }
-
-      if (!(instance instanceof Clz)) {
-        throw new Error(`Expected '${String(id)}' instance in ${String(ctx)}`);
-      }
-
-      return instance.ref;
-    }
-
-    const flushes: any[] = [];
-    const blacklistFlushes = [
-      "ThreadDispatcher",
-      "HttpClient",
-      "WebSocketClient",
-      "PathResolver",
-      "LogPrinter",
-      "RandomNumberGenerator",
-      "DatabaseBackend",
-      "DynamicObject",
-      "WalletPool",
-      "SerialContext",
-      "",
-    ];
-
-    function declare(id: string, { methods, statics }: Spec) {
-      const native = getNativeModule(id);
-
-      if (!blacklistFlushes.includes(id)) {
-        flushes.push(() => {
-          try {
-            return native.flush();
-          } catch (e) {
-            console.warn("no flush for " + id);
-          }
-        });
-      }
-
-      // There are lot of decoration done to abstract out libcore api.
-      // The plan is to make it converge to this API in the future
-      // so we have less runtime wrapping.
-      const unwrapArgs = (args, params, ctx) =>
-        params
-          ? [...args].map((value, i) => {
-              const spec = params[i];
-              return spec ? unwrap(spec, value, ctx) : value;
-            })
-          : args;
-
-      const wrapResult = (r, returns) => {
-        let res = r;
-
-        if (res && typeof res === "object") {
-          if (res.then) {
-            return res.then((re) => wrapResult(re, returns));
-          }
-
-          if ("value" in res) {
-            res = res.value;
-          }
-        }
-
-        if (!returns) return res;
-        return wrap(returns, res);
-      };
-
-      const proto = {};
-
-      if (methods) {
-        Object.keys(methods).forEach((method) => {
-          const { returns, params } = methods[method];
-          const f = native && native[method];
-
-          if (!f) {
-            console.warn(
-              `LibCore: module '${id}' method '${method}' is missing in native side`
-            );
-          }
-
-          const ctx = `${id}#${method}`;
-
-          proto[method] = function fn(...args) {
-            const unwrapped = unwrapArgs(args, params, ctx);
-            const r = f.call(native, unwrap(id, this, ctx), ...unwrapped);
-            return wrapResult(r, returns);
-          };
-        });
-      }
-
-      function constructor(ref) {
-        this.ref = ref;
-      }
-
-      constructor.prototype = proto;
-
-      if (statics) {
-        Object.keys(statics).forEach((method) => {
-          const { returns, params } = statics[method];
-          const f = native && native[method];
-
-          if (!f) {
-            console.warn(
-              `LibCore: module '${id}' static method '${method}' is missing in native side`
-            );
-          }
-
-          const ctx = `${id}.${method}`;
-
-          constructor[method] = (...args) => {
-            const unwrapped = unwrapArgs(args, params, ctx);
-            const r = f.call(native, ...unwrapped);
-            return wrapResult(r, returns);
-          };
-        });
-      }
-
-      if (id in mappings) {
-        console.warn("LibCore: Already declared " + id);
-      }
-
-      mappings[id] = constructor;
-    }
-
-    reflect(declare);
-    const cs: CoreStatics = <CoreStatics>mappings;
-    const threadDispatcher = await cs.ThreadDispatcher.newInstance();
-    const httpClient = await cs.HttpClient.newInstance();
-    const webSocket = await cs.WebSocketClient.newInstance();
-    const pathResolver = await cs.PathResolver.newInstance();
-    const logPrinter = await cs.LogPrinter.newInstance();
-    const rng = await cs.RandomNumberGenerator.newInstance();
-    const backend = await cs.DatabaseBackend.getSqlite3Backend();
-    const walletDynObject = await cs.DynamicObject.newInstance();
-    const walletPoolInstance = await cs.WalletPool.newInstance(
-      "ledgerlive",
-      "",
-      httpClient,
-      webSocket,
-      pathResolver,
-      logPrinter,
-      threadDispatcher,
-      rng,
-      backend,
-      walletDynObject
-    );
-    const core = {
-      ...cs,
-      flush: () => Promise.all(flushes.map((f) => f())).then(() => undefined),
-      getPoolInstance: () => walletPoolInstance,
-      getThreadDispatcher: () => threadDispatcher,
-    } as Core;
-    return core;
-  }
-
-  function remapLibcoreErrors(error: unknown): Error {
-    if (!(error && error instanceof Error)) {
-      return new Error(String(error));
-    }
-
-    if (!error || !error.message) return error;
-    const msg = error.message;
-
-    if (
-      msg.includes("Cannot gather enough funds") ||
-      msg.includes("There is no UTXO on this account.")
-    ) {
-      return new NotEnoughBalance();
-    }
-
-    if (
-      msg.includes("The Internet connection appears to be offline") ||
-      msg.includes(
-        '"explorers.api.live.ledger.com": No address associated with hostname'
-      )
-    ) {
-      return new NetworkDown();
-    }
-
-    // Attempt to recover the human readable error from a verbose iOS trace
-    const pattern = /NS[\w]+Error.+Code.+"([\w .]+)"/;
-    const match = pattern.exec(msg);
-
-    if (match && match[1] !== "(null)") {
-      return new Error(match[1]);
-    }
-
-    return error;
-  }
-
-  setLoadCoreImplementation(loadCore);
-  setRemapLibcoreErrorsImplementation(remapLibcoreErrors);
-};

package/src/libcore/scanAccounts.ts

@@ -1,280 +0,0 @@
-import { Observable } from "rxjs";
-import Transport from "@ledgerhq/hw-transport";
-import { log } from "@ledgerhq/logs";
-import { TransportStatusError, UserRefusedAddress } from "@ledgerhq/errors";
-import semver from "semver";
-import {
-  getDerivationModesForCurrency,
-  getSeedIdentifierDerivation,
-  derivationModeSupportsIndex,
-  isIterableDerivationMode,
-  getMandatoryEmptyAccountSkip,
-  getDerivationModeStartsAt,
-} from "../derivation";
-import { getWalletName, shouldShowNewAccount } from "../account";
-import type {
-  Account,
-  CryptoCurrency,
-  DerivationMode,
-  ScanAccountEvent,
-  SyncConfig,
-} from "../types";
-import { withDevice } from "../hw/deviceAccess";
-import getAddress from "../hw/getAddress";
-import getAppAndVersion from "../hw/getAppAndVersion";
-import { withLibcoreF } from "./access";
-import { syncCoreAccount, newSyncLogId } from "./syncAccount";
-import { getOrCreateWallet } from "./getOrCreateWallet";
-import {
-  DerivationsCache,
-  createAccountFromDevice,
-} from "./createAccountFromDevice";
-import { remapLibcoreErrors, isNonExistingAccountError } from "./errors";
-import { GetAppAndVersionUnsupportedFormat } from "../errors";
-import nativeSegwitAppsVersionsMap from "./nativeSegwitAppsVersionsMap";
-import type { Core, CoreWallet } from "./types";
-import { GetAddressOptions, Result } from "../hw/getAddress/types";
-
-async function scanNextAccount(props: {
-  core: Core;
-  wallet: CoreWallet;
-  currency: CryptoCurrency;
-  accountIndex: number;
-  onAccountScanned: (arg0: Account) => any;
-  seedIdentifier: string;
-  derivationMode: DerivationMode;
-  showNewAccount: boolean;
-  isUnsubscribed: () => boolean;
-  emptyCount?: number;
-  syncConfig: SyncConfig;
-  derivationsCache: DerivationsCache;
-  getAddr: (opts: GetAddressOptions) => Promise<Result>;
-}) {
-  const logId = newSyncLogId();
-  const {
-    core,
-    wallet,
-    currency,
-    accountIndex,
-    onAccountScanned,
-    seedIdentifier,
-    derivationMode,
-    showNewAccount,
-    isUnsubscribed,
-    syncConfig,
-    derivationsCache,
-    getAddr,
-  } = props;
-  log(
-    "libcore",
-    `sync(${logId}) scanNextAccount started. ${currency.id}|${derivationMode}|${accountIndex}`
-  );
-  let coreAccount;
-
-  try {
-    coreAccount = await wallet.getAccount(accountIndex);
-  } catch (err: any) {
-    if (!isNonExistingAccountError(err)) {
-      throw err;
-    }
-
-    if (isUnsubscribed()) return;
-    coreAccount = await createAccountFromDevice({
-      core,
-      wallet,
-      currency,
-      index: accountIndex,
-      derivationMode,
-      isUnsubscribed,
-      derivationsCache,
-      getAddress: getAddr,
-    });
-  }
-
-  if (isUnsubscribed() || !coreAccount) return;
-  const account = await syncCoreAccount({
-    core,
-    coreWallet: wallet,
-    coreAccount,
-    currency,
-    accountIndex,
-    derivationMode,
-    seedIdentifier,
-    logId,
-    syncConfig,
-  });
-  if (isUnsubscribed()) return;
-  const shouldSkip =
-    accountIndex < getDerivationModeStartsAt(derivationMode) ||
-    (!account.used && !showNewAccount) ||
-    !derivationModeSupportsIndex(derivationMode, accountIndex);
-  log(
-    "libcore",
-    `scanning ${currency.id} ${
-      derivationMode || "default"
-    }@${accountIndex}: resulted of ${
-      account && !shouldSkip
-        ? `Account with ${account.operationsCount} txs (xpub ${String(
-            account.xpub
-          )}, fresh ${account.freshAddressPath} ${account.freshAddress})`
-        : "no account"
-    }. ${!account.used ? "ALL SCANNED" : ""}`
-  );
-
-  if (!shouldSkip) {
-    onAccountScanned(account);
-  }
-
-  const emptyCount = props.emptyCount || 0;
-  const shouldIter = !account.used
-    ? emptyCount < getMandatoryEmptyAccountSkip(derivationMode)
-    : isIterableDerivationMode(derivationMode);
-
-  if (shouldIter) {
-    await scanNextAccount({
-      ...props,
-      accountIndex: accountIndex + 1,
-      emptyCount: !account.used ? emptyCount + 1 : 0,
-    });
-  }
-}
-
-const libcoreBlacklist = ["taproot"];
-
-export const scanAccounts = ({
-  currency,
-  deviceId,
-  scheme,
-  syncConfig,
-  getAddressFn,
-}: {
-  currency: CryptoCurrency;
-  deviceId: string;
-  scheme?: DerivationMode | null | undefined;
-  syncConfig: SyncConfig;
-  getAddressFn?: (
-    transport: Transport
-  ) => (opts: GetAddressOptions) => Promise<Result>;
-}): Observable<ScanAccountEvent> =>
-  withDevice(deviceId)((transport) =>
-    Observable.create((o) => {
-      let finished = false;
-
-      const unsubscribe = () => {
-        finished = true;
-      };
-
-      const isUnsubscribed = () => finished;
-
-      const main = withLibcoreF((core) => async () => {
-        try {
-          let derivationModes = getDerivationModesForCurrency(currency);
-
-          if (scheme !== undefined) {
-            derivationModes = derivationModes.filter((mode) => mode === scheme);
-          }
-
-          derivationModes = derivationModes.filter(
-            (m) => !libcoreBlacklist.includes(m)
-          );
-
-          for (let i = 0; i < derivationModes.length; i++) {
-            const derivationMode = derivationModes[i];
-            const path = getSeedIdentifierDerivation(currency, derivationMode);
-            let result;
-
-            if (derivationMode === "native_segwit") {
-              if (nativeSegwitAppsVersionsMap[currency.managerAppName]) {
-                try {
-                  const { version } = await getAppAndVersion(transport);
-
-                  if (
-                    !semver.gte(
-                      version,
-                      nativeSegwitAppsVersionsMap[currency.managerAppName]
-                    )
-                  ) {
-                    continue;
-                  }
-                } catch (e) {
-                  // in case the apdu is not even supported, we assume to not do native_segwit
-                  if (
-                    (e instanceof TransportStatusError &&
-                      // @ts-expect-error TransportStatusError to be typed on ledgerjs
-                      e.statusCode === 0x6d00) ||
-                    e instanceof GetAppAndVersionUnsupportedFormat
-                  ) {
-                    continue;
-                  }
-
-                  throw e;
-                }
-              }
-            }
-
-            const getAddr = getAddressFn
-              ? getAddressFn(transport)
-              : (opts) => getAddress(transport, opts);
-
-            try {
-              result = await getAddr({ currency, path, derivationMode });
-            } catch (e) {
-              // feature detection: some old app will specifically returns this code for segwit case and we ignore it
-              // we also feature detect any denying case that could happen
-              if (
-                e instanceof TransportStatusError ||
-                e instanceof UserRefusedAddress
-              ) {
-                log("scanAccounts", "ignore derivationMode=" + derivationMode);
-              }
-            }
-
-            if (!result) continue;
-            const seedIdentifier = result.publicKey;
-            if (isUnsubscribed()) return;
-            const walletName = getWalletName({
-              seedIdentifier,
-              currency,
-              derivationMode,
-            });
-            const wallet = await getOrCreateWallet({
-              core,
-              walletName,
-              currency,
-              derivationMode,
-            });
-            if (isUnsubscribed()) return;
-
-            const onAccountScanned = (account) =>
-              o.next({
-                type: "discovered",
-                account,
-              });
-
-            // recursively scan all accounts on device on the given app
-            // new accounts will be created in sqlite, existing ones will be updated
-            await scanNextAccount({
-              core,
-              wallet,
-              currency,
-              accountIndex: 0,
-              onAccountScanned,
-              seedIdentifier,
-              derivationMode,
-              showNewAccount: shouldShowNewAccount(currency, derivationMode),
-              isUnsubscribed,
-              syncConfig,
-              derivationsCache: new DerivationsCache(),
-              getAddr,
-            });
-          }
-
-          o.complete();
-        } catch (e) {
-          o.error(remapLibcoreErrors(e));
-        }
-      });
-      main();
-      return unsubscribe;
-    })
-  );

package/src/libcore/signOperation.ts

@@ -1,141 +0,0 @@
-import { Observable, from } from "rxjs";
-import { tap } from "rxjs/operators";
-import Transport from "@ledgerhq/hw-transport";
-import { StatusCodes } from "@ledgerhq/hw-transport";
-import { UpdateYourApp } from "@ledgerhq/errors";
-import { log } from "@ledgerhq/logs";
-import type {
-  AccountBridge,
-  Account,
-  CryptoCurrency,
-  SignedOperation,
-  Transaction,
-  DerivationMode,
-  SignOperationEvent,
-} from "../types";
-import type { Core, CoreAccount, CoreCurrency, CoreWallet } from "./types";
-import { withDevice } from "../hw/deviceAccess";
-import { toTransactionRaw, toSignOperationEventRaw } from "../transaction";
-import { getCoreAccount } from "./getCoreAccount";
-import { remapLibcoreErrors } from "./errors";
-import { withLibcore } from "./access";
-
-export type Arg<T, CT> = {
-  buildTransaction: (arg0: {
-    account: Account;
-    core: Core;
-    coreCurrency: CoreCurrency;
-    coreAccount: CoreAccount;
-    coreWallet: CoreWallet;
-    transaction: T;
-    isPartial: boolean;
-    isCancelled: () => boolean;
-  }) => Promise<CT | null | undefined>;
-  signTransaction: (arg0: {
-    account: Account;
-    subAccountId: string | null | undefined;
-    transport: Transport;
-    currency: CryptoCurrency;
-    derivationMode: DerivationMode;
-    coreCurrency: CoreCurrency;
-    transaction: T;
-    coreTransaction: CT;
-    coreAccount: CoreAccount;
-    isCancelled: () => boolean;
-    onDeviceStreaming: (arg0: {
-      progress: number;
-      index: number;
-      total: number;
-    }) => void;
-    onDeviceSignatureRequested: () => void;
-    onDeviceSignatureGranted: () => void;
-  }) => Promise<SignedOperation | null | undefined>;
-};
-
-type SignOperation<T extends Transaction> = AccountBridge<T>["signOperation"];
-
-export const makeSignOperation =
-  <T extends Transaction, CT>({
-    buildTransaction,
-    signTransaction,
-  }: Arg<T, CT>): SignOperation<T> =>
-  ({ account, transaction, deviceId }) =>
-    Observable.create((o) => {
-      let cancelled = false;
-      withLibcore(async (core) => {
-        if (cancelled) return;
-        const { currency, derivationMode } = account;
-        const { coreAccount, coreWallet } = await getCoreAccount(core, account);
-        if (cancelled) return;
-        const coreCurrency = await coreWallet.getCurrency();
-        if (cancelled) return;
-        log("libcore", "buildTransaction", toTransactionRaw(transaction));
-        const builded = await buildTransaction({
-          account,
-          core,
-          coreCurrency,
-          coreAccount,
-          transaction,
-          coreWallet,
-          isPartial: false,
-          isCancelled: () => cancelled,
-        });
-        if (cancelled || !builded) return;
-        const signedOperation = await withDevice(deviceId)((transport) =>
-          from(
-            signTransaction({
-              account,
-              subAccountId: transaction.subAccountId,
-              transport,
-              currency,
-              derivationMode,
-              coreCurrency,
-              coreAccount,
-              transaction,
-              coreTransaction: builded,
-              isCancelled: () => cancelled,
-              onDeviceStreaming: ({ progress, index, total }) =>
-                o.next({
-                  type: "device-streaming",
-                  progress,
-                  index,
-                  total,
-                }),
-              onDeviceSignatureRequested: () =>
-                o.next({
-                  type: "device-signature-requested",
-                }),
-              onDeviceSignatureGranted: () =>
-                o.next({
-                  type: "device-signature-granted",
-                }),
-            }).catch((e) => {
-              // TODO where to remap this generically???
-              if (e && e.statusCode === StatusCodes.INCORRECT_P1_P2) {
-                throw new UpdateYourApp(
-                  `UpdateYourApp ${currency.id}`,
-                  currency
-                );
-              }
-
-              throw e;
-            })
-          )
-        ).toPromise();
-        if (cancelled || !signedOperation) return;
-        o.next({
-          type: "signed",
-          signedOperation,
-        });
-      }).then(
-        () => o.complete(),
-        (e) => o.error(remapLibcoreErrors(e))
-      );
-      return () => {
-        cancelled = true;
-      };
-    }).pipe(
-      tap((e: SignOperationEvent) =>
-        log("signOperation", "event " + e.type, toSignOperationEventRaw(e))
-      )
-    );