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

package/src/types/bridge.ts

@@ -1,201 +0,0 @@
-// NB this new "bridge" is a re-take of live-desktop bridge ideas
-// with a focus to eventually make it shared across both projects.
-// a WalletBridge is implemented on renderer side.
-// this is an abstraction on top of underlying blockchains api (libcore / ethereumjs / ripple js / ...)
-// that would directly be called from UI needs.
-import { BigNumber } from "bignumber.js";
-import type { Observable } from "rxjs";
-import type {
-  AccountLike,
-  Account,
-  AccountRaw,
-  CryptoCurrency,
-  TransactionStatus,
-  Transaction,
-  SignOperationEvent,
-  SignedOperation,
-  Operation,
-  DerivationMode,
-  SyncConfig,
-  CryptoCurrencyIds,
-  NFTMetadataResponse,
-} from ".";
-import {
-  NFTCollectionMetadata,
-  NFTCollectionMetadataResponse,
-  NFTMetadata,
-} from "./nft";
-export type ScanAccountEvent = {
-  type: "discovered";
-  account: Account;
-};
-// more events will come in the future
-export type ScanAccountEventRaw = {
-  type: "discovered";
-  account: AccountRaw;
-};
-// unique identifier of a device. it will depends on the underlying implementation.
-export type DeviceId = string;
-export type PreloadStrategy = Partial<{
-  preloadMaxAge: number;
-}>;
-
-export type BroadcastArg0 = {
-  account: Account;
-  signedOperation: SignedOperation;
-};
-export type SignOperationArg0<T> = {
-  account: Account;
-  transaction: T;
-  deviceId: DeviceId;
-};
-export type SignOperationFnSignature<T> = (
-  arg0: SignOperationArg0<T>
-) => Observable<SignOperationEvent>;
-export type BroadcastFnSignature = (arg0: BroadcastArg0) => Promise<Operation>;
-// Abstraction related to a currency
-export interface CurrencyBridge {
-  // Preload data required for the bridges to work. (e.g. tokens, delegators,...)
-  // Assume to call it at every load time but as lazy as possible (if user have such account already AND/OR if user is about to scanAccounts)
-  // returned value is a serializable object
-  // fail if data was not able to load.
-  preload(currency: CryptoCurrency): Promise<Record<string, any>>;
-  // reinject the preloaded data (typically if it was cached)
-  // method need to treat the data object as unsafe and validate all fields / be backward compatible.
-  hydrate(data: unknown, currency: CryptoCurrency): void;
-  // Scan all available accounts with a device
-  scanAccounts(arg0: {
-    currency: CryptoCurrency;
-    deviceId: DeviceId;
-    scheme?: DerivationMode | null | undefined;
-    syncConfig: SyncConfig;
-    preferredNewAccountScheme?: DerivationMode;
-  }): Observable<ScanAccountEvent>;
-  getPreloadStrategy?: (currency: CryptoCurrency) => PreloadStrategy;
-  nftResolvers?: {
-    nftMetadata: (arg: {
-      contract: string;
-      tokenId: string;
-      currencyId: string;
-      metadata?: NFTMetadata;
-    }) => Promise<NFTMetadataResponse>;
-    collectionMetadata: (arg: {
-      contract: string;
-      currencyId: string;
-      metadata?: NFTCollectionMetadata;
-    }) => Promise<NFTCollectionMetadataResponse>;
-  };
-}
-// Abstraction related to an account
-export interface AccountBridge<T extends Transaction> {
-  // synchronizes an account continuously to update with latest blochchains state.
-  // The function emits updater functions each time there are data changes (e.g. blockchains updates)
-  // an update function is just a Account => Account that perform the changes (to avoid race condition issues)
-  // initialAccount parameter is used to point which account is the synchronization on, but it should not be used in the emitted values.
-  // the sync can be stopped at any time using Observable's subscription.unsubscribe()
-  sync(
-    initialAccount: Account,
-    syncConfig: SyncConfig
-  ): Observable<(arg0: Account) => Account>;
-  receive(
-    account: Account,
-    arg1: {
-      verify?: boolean;
-      deviceId: string;
-      subAccountId?: string;
-      freshAddressIndex?: number;
-    }
-  ): Observable<{
-    address: string;
-    path: string;
-  }>;
-  // a Transaction object is created on UI side as a black box to put all temporary information to build the transaction at the end.
-  // There are a bunch of edit and get functions to edit and extract information out ot this black box.
-  // it needs to be a serializable JS object
-  createTransaction(account: Account): T;
-  updateTransaction(t: T, patch: Partial<T>): T;
-  // prepare the remaining missing part of a transaction typically from network (e.g. fees)
-  // and fulfill it in a new transaction object that is returned (async)
-  // It can fails if the the network is down.
-  prepareTransaction(account: Account, transaction: T): Promise<T>;
-  // calculate derived state of the Transaction, useful to display summary / errors / warnings. tells if the transaction is ready.
-  getTransactionStatus(
-    account: Account,
-    transaction: T
-  ): Promise<TransactionStatus>;
-  // heuristic that provides the estimated max amount that can be set to a send.
-  // this is usually the balance minus the fees, but it really depends between coins (reserve, burn, frozen part of the balance,...).
-  // it is a heuristic in that this is not necessarily correct and it can be +-delta (so the info can exceed the spendable or leave some dust).
-  // it's used as informative UI and also used for "dry run" approaches, but it shouldn't be used to determine the final SEND MAX amount.
-  // it returns an amount in the account unit
-  // if a transaction is provided, it can be used to precise the information
-  // if it not provided, you can assume to take the worst-case scenario (like sending all UTXOs to a legacy address has higher fees resulting in a lower max spendable)
-  estimateMaxSpendable(arg0: {
-    account: AccountLike;
-    parentAccount?: Account | null | undefined;
-    transaction?: T | null | undefined;
-  }): Promise<BigNumber>;
-  // finalizing a transaction by signing it with the ledger device
-  // This results of a "signed" event with a signedOperation
-  // than can be locally saved and later broadcasted
-  signOperation: SignOperationFnSignature<T>;
-  // broadcasting a signed transaction to network
-  // returns an optimistic Operation that this transaction is likely to create in the future
-  broadcast: BroadcastFnSignature;
-}
-type ExpectFn = (...args: Array<any>) => any;
-export type CurrenciesData<T extends Transaction> = {
-  FIXME_ignoreAccountFields?: string[];
-  FIXME_ignoreOperationFields?: string[];
-  FIXME_ignorePreloadFields?: string[];
-  mockDeviceOptions?: any;
-  scanAccounts?: Array<{
-    name: string;
-    apdus: string;
-    unstableAccounts?: boolean;
-    test?: (
-      expect: ExpectFn,
-      scanned: Account[],
-      bridge: CurrencyBridge
-    ) => any;
-  }>;
-  accounts?: Array<{
-    implementations?: string[];
-    raw: AccountRaw;
-    FIXME_tests?: Array<string | RegExp>;
-    transactions?: Array<{
-      name: string;
-      transaction: T | ((arg0: T, arg1: Account, arg2: AccountBridge<T>) => T);
-      expectedStatus?:
-        | Partial<TransactionStatus>
-        | ((
-            arg0: Account,
-            arg1: T,
-            arg2: TransactionStatus
-          ) => Partial<TransactionStatus>);
-      test?: (
-        arg0: ExpectFn,
-        arg1: T,
-        arg2: TransactionStatus,
-        arg3: AccountBridge<T>
-      ) => any;
-      apdus?: string;
-      testSignedOperation?: (
-        arg0: ExpectFn,
-        arg1: SignedOperation,
-        arg2: Account,
-        arg3: T,
-        arg4: TransactionStatus,
-        arg5: AccountBridge<T>
-      ) => any;
-    }>;
-    test?: (arg0: ExpectFn, arg1: Account, arg2: AccountBridge<T>) => any;
-  }>;
-  test?: (arg0: ExpectFn, arg1: CurrencyBridge) => any;
-};
-export type DatasetTest<T extends Transaction> = {
-  implementations: string[];
-  currencies:
-    | Record<CryptoCurrencyIds, CurrenciesData<T>>
-    | Record<string, never>;
-};

package/src/types/currencies.ts

@@ -1,18 +0,0 @@
-import type {
-  Unit,
-  ExplorerView,
-  TokenCurrency,
-  CryptoCurrency,
-  FiatCurrency,
-  Currency,
-  CryptoCurrencyIds,
-} from "@ledgerhq/cryptoassets";
-export type {
-  Unit,
-  ExplorerView,
-  TokenCurrency,
-  CryptoCurrency,
-  FiatCurrency,
-  Currency,
-  CryptoCurrencyIds,
-};

package/src/types/index.ts

@@ -1,13 +0,0 @@
-export * from "../derivation";
-export * from "./currencies";
-export * from "./account";
-export * from "./operation";
-export * from "./portfolio";
-export * from "../account/groupOperations";
-export * from "../account/accountId";
-export * from "./transaction";
-export * from "../generated/types";
-export * from "./bridge";
-export * from "./pagination";
-export * from "./nft";
-export * from "../featureFlags/types";

package/src/types/manager.ts

@@ -1,252 +0,0 @@
-import type { CryptoCurrency } from "./currencies";
-import type { DeviceModelId } from "@ledgerhq/devices";
-// FIXME we need to clearly differentiate what is API types and what is our inner own type
-export type Id = number;
-export type LedgerScriptParams = {
-  firmware: string;
-  firmwareKey: string;
-  delete?: string;
-  deleteKey?: string;
-  targetId?: string | number;
-  hash: string;
-  perso: string;
-};
-export type DeviceInfo = {
-  mcuVersion: string;
-  // the raw mcu version
-  version: string;
-  // the version part, without the -osu
-  majMin: string;
-  // the x.y part of the x.y.z-v version
-  targetId: string | number;
-  // a technical id
-  isBootloader: boolean;
-  isRecoveryMode?: boolean;
-  isOSU: boolean;
-  providerName: string | null | undefined;
-  managerAllowed: boolean;
-  pinValidated: boolean;
-  // more precised raw versions
-  seVersion?: string;
-  mcuBlVersion?: string;
-  mcuTargetId?: number;
-  seTargetId?: number;
-  onboarded?: boolean;
-};
-export type DeviceModelInfo = {
-  modelId: DeviceModelId;
-  deviceInfo: DeviceInfo;
-  apps: Array<{
-    name: string;
-    version: string;
-  }>;
-};
-export type DeviceVersion = {
-  id: Id;
-  name: string;
-  display_name: string;
-  target_id: string;
-  description: string;
-  device: Id;
-  providers: Array<Id>;
-  mcu_versions: Array<Id>;
-  se_firmware_final_versions: Array<Id>;
-  osu_versions: Array<Id>;
-  application_versions: Array<Id>;
-  date_creation: string;
-  date_last_modified: string;
-};
-export type McuVersion = {
-  id: Id;
-  mcu: Id;
-  name: string;
-  description: string | null | undefined;
-  providers: Array<Id>;
-  from_bootloader_version: string;
-  device_versions: Array<Id>;
-  se_firmware_final_versions: Array<Id>;
-  date_creation: string;
-  date_last_modified: string;
-};
-export enum SeedPhraseType {
-  Twelve = "12-words",
-  Eighteen = "18-words",
-  TwentyFour = "24-words",
-}
-export type FirmwareInfo = {
-  isBootloader: boolean;
-  rawVersion: string; // if SE seVersion, if BL blVersion
-  targetId: number; // if SE seTargetId, if BL mcuTargetId
-  seVersion?: string;
-  mcuVersion: string; // NB historically not undefined. but will be ""
-  mcuBlVersion?: string;
-  mcuTargetId?: number;
-  seTargetId?: number;
-  flags: Buffer;
-};
-type BaseFirmware = {
-  id: Id;
-  name: string;
-  description: string | null | undefined;
-  display_name: string | null | undefined;
-  notes: string | null | undefined;
-  perso: string;
-  firmware: string;
-  firmware_key: string;
-  hash: string;
-  date_creation: string;
-  date_last_modified: string;
-  device_versions: Array<Id>;
-  providers: Array<Id>;
-};
-export type OsuFirmware = BaseFirmware & {
-  next_se_firmware_final_version: Id;
-  previous_se_firmware_final_version: Array<Id>;
-};
-export type FinalFirmware = BaseFirmware & {
-  version: string;
-  se_firmware: Id;
-  osu_versions: Array<OsuFirmware>;
-  mcu_versions: Array<Id>;
-  application_versions: Array<Id>;
-  bytes?: number;
-  updateAvailable?: FirmwareUpdateContext | null | undefined;
-};
-export type FirmwareUpdateContext = {
-  osu: OsuFirmware;
-  final: FinalFirmware;
-  shouldFlashMCU: boolean;
-};
-export type ApplicationVersion = {
-  id: Id;
-  name: string;
-  version: string;
-  app: Id;
-  description: string | null | undefined;
-  display_name: string;
-  icon: string;
-  notes: string | null | undefined;
-  perso: string;
-  hash: string;
-  firmware: string;
-  firmware_key: string;
-  delete: string;
-  delete_key: string;
-  device_versions: Array<Id>;
-  se_firmware_final_versions: Array<Id>;
-  providers: Array<Id>;
-  date_creation: string;
-  date_last_modified: string;
-  type?: AppType;
-  // dependencies: Id[],
-  bytes: number | null | undefined;
-  warning: string | null | undefined;
-  // DEPRECATED because not serializable
-  currency?: CryptoCurrency;
-};
-export type Application = {
-  id: Id;
-  name: string;
-  description: string | null | undefined;
-  application_versions: Array<ApplicationVersion>;
-  providers: Array<Id>;
-  category: Id;
-  publisher: Id | null | undefined;
-  date_creation: string;
-  date_last_modified: string;
-  currencyId: string | null | undefined;
-  authorName: string | null | undefined;
-  supportURL: string | null | undefined;
-  contactURL: string | null | undefined;
-  sourceURL: string | null | undefined;
-  compatibleWalletsJSON: string | null | undefined;
-};
-export enum AppType {
-  app = "app",
-  plugin = "plugin",
-  tool = "tool",
-  swap = "swap",
-}
-// App is higher level on top of Application and ApplicationVersion
-// with all fields Live needs and in normalized form (but still serializable)
-export type App = {
-  id: Id;
-  name: string;
-  displayName: string;
-  version: string;
-  currencyId: string | null | undefined;
-  description: string | null | undefined;
-  dateModified: string;
-  icon: string;
-  authorName: string | null | undefined;
-  supportURL: string | null | undefined;
-  contactURL: string | null | undefined;
-  sourceURL: string | null | undefined;
-  compatibleWallets: Array<{
-    name: string;
-    url: string | null | undefined;
-  }>;
-  hash: string;
-  perso: string;
-  firmware: string;
-  firmware_key: string;
-  delete: string;
-  delete_key: string;
-  // we use names to identify an app
-  dependencies: string[];
-  bytes: number | null | undefined;
-  warning: string | null | undefined;
-  // -1 if coin not in marketcap, otherwise index in the tickers list of https://countervalues.api.live.ledger.com/tickers
-  indexOfMarketCap: number;
-  isDevTools: boolean;
-  type: AppType;
-};
-export type Category = {
-  id: Id;
-  name: string;
-  description: string | null | undefined;
-  providers: Array<Id>;
-  applications: Array<Id>;
-  date_creation: string;
-  date_last_modified: string;
-};
-export type SocketEvent =
-  | {
-      type: "bulk-progress";
-      progress: number;
-      index: number;
-      total: number;
-    }
-  | {
-      type: "result";
-      payload: any;
-    }
-  | {
-      type: "warning";
-      message: string;
-    }
-  | {
-      type: "device-permission-requested";
-      wording: string;
-    }
-  | {
-      type: "device-permission-granted";
-    }
-  | {
-      type: "exchange-before";
-      nonce: number;
-      apdu: Buffer;
-    }
-  | {
-      type: "exchange";
-      nonce: number;
-      apdu: Buffer;
-      data: Buffer;
-      status: number;
-    }
-  | {
-      type: "opened";
-    }
-  | {
-      type: "closed";
-    };

package/src/types/nft.ts

@@ -1,76 +0,0 @@
-import type BigNumber from "bignumber.js";
-import { CryptoCurrencyIds } from ".";
-
-export type NFTStandard = "ERC721" | "ERC1155";
-
-export type NFTMediaSizes = "preview" | "big" | "original";
-
-export type NFTMedias = Record<
-  NFTMediaSizes,
-  {
-    uri: string;
-    mediaType: string; // mime-type
-  }
->;
-
-export type NFTMetadata = {
-  tokenName: string | null;
-  nftName: string | null;
-  medias: NFTMedias;
-  description: string | null;
-  properties: Array<Record<"key" | "value", string>>;
-  links: Record<NFTMetadataLinksProviders, string>;
-};
-
-export type NFTCollectionMetadata = {
-  tokenName: string | null;
-};
-
-export type ProtoNFT = {
-  // id crafted by live
-  id: string;
-  // id on chain
-  tokenId: string;
-  amount: BigNumber;
-  contract: string;
-  standard: NFTStandard;
-  currencyId: CryptoCurrencyIds;
-  metadata?: NFTMetadata;
-};
-
-export type ProtoNFTRaw = Omit<ProtoNFT, "amount"> & {
-  amount: string;
-};
-
-export type NFT = Omit<ProtoNFT, "metadata"> & {
-  metadata: NFTMetadata;
-};
-
-export type NFTMetadataLinksProviders = "opensea" | "rarible" | "explorer";
-
-export type NFTMetadataResponse = {
-  status: 200 | 404 | 500;
-  result?: {
-    contract: string;
-    tokenId: string;
-    tokenName: string | null;
-    nftName: string | null;
-    medias: NFTMedias;
-    description: string | null;
-    properties: Array<Record<"key" | "value", string>>;
-    links: Record<NFTMetadataLinksProviders, string>;
-  } | null;
-};
-
-export type NFTCollectionMetadataResponse = {
-  status: 200 | 404 | 500;
-  result?: {
-    contract: string;
-    tokenName: string | null;
-  } | null;
-};
-
-export type FloorPrice = {
-  ticker: string;
-  value: number;
-};

package/src/types/operation.ts

@@ -1,119 +0,0 @@
-import type { BigNumber } from "bignumber.js";
-import { NFTStandard } from "./nft";
-
-export type OperationType =
-  | "IN"
-  | "OUT"
-  | "NONE"
-  | "CREATE"
-  | "REVEAL"
-  // COSMOS
-  | "DELEGATE"
-  | "UNDELEGATE"
-  | "REDELEGATE"
-  | "REWARD"
-  // TRON
-  | "FEES"
-  | "FREEZE"
-  | "UNFREEZE"
-  // POLKADOT
-  | "VOTE"
-  | "REWARD_PAYOUT"
-  | "BOND"
-  | "UNBOND"
-  | "WITHDRAW_UNBONDED"
-  | "SET_CONTROLLER"
-  | "SLASH"
-  | "NOMINATE"
-  | "CHILL"
-  // COMPOUND TYPE OPERATIONS
-  | "SUPPLY"
-  | "REDEEM"
-  | "APPROVE"
-  // ALGORAND
-  | "OPT_IN"
-  | "OPT_OUT"
-  // NFT
-  | "NFT_IN"
-  | "NFT_OUT";
-export type Operation = {
-  // unique identifier (usually hash)
-  id: string;
-  // transaction hash
-  hash: string;
-  // the direction of the operation
-  // IN when funds was received (means the related account is in the recipients)
-  // OUT when funds was sent (means the related account is in the senders)
-  // NONE means this is not an operation related to the account but exists because there is likely an internal transaction
-  type: OperationType;
-  // this is the atomic value of the operation. it is always positive (later will be a BigInt)
-  // in "OUT" case, it includes the fees. in "IN" case, it excludes them.
-  value: BigNumber;
-  // fee of the transaction (in satoshi value)
-  fee: BigNumber;
-  // senders & recipients addresses
-  senders: string[];
-  recipients: string[];
-  // if block* are null, the operation is not yet on the blockchain
-  // the height of the block on the blockchain (number)
-  blockHeight: number | null | undefined;
-  // the hash of the block the operation is in
-  blockHash: string | null | undefined;
-  // if available, this is the sequence number of the transaction in blockchains (aka "nonce" in Ethereum)
-  transactionSequenceNumber?: number;
-  // the account id. available for convenient reason
-  accountId: string;
-  // --------------------------------------------- properties related to NFTs
-  // the specification used for the transaction's event
-  standard?: NFTStandard | string;
-  // address of an account/contract that is approved to make the transfer
-  operator?: string;
-  // address of the contract/collection containing an NFT (tokenId)
-  contract?: string;
-  // Id of an NFT inside its collection/contract
-  tokenId?: string;
-  // --------------------------------------------- specific operation raw fields
-  // transaction date
-  date: Date;
-  // Extra crypto specific fields
-  extra: Record<string, any>;
-  // Has the transaction actually failed? (some blockchain like ethereum will have failed tx appearing)
-  hasFailed?: boolean;
-  // in context of accounts that can have tokens, an operation can contains itself operations
-  // these are not in raw at all because they are meant to be rebuilt from the references
-  subOperations?: Operation[];
-  // in context of accounts that have internal transactions that belong to a parent transaction
-  // we have internal operations. Those are not included in the top level operations but can be presented to UI at that same level
-  internalOperations?: Operation[];
-  // Operations related to ERC721 | ERC1155 tokens
-  nftOperations?: Operation[];
-};
-export type OperationRaw = {
-  id: string;
-  hash: string;
-  type: OperationType;
-  value: string;
-  fee: string;
-  senders: string[];
-  recipients: string[];
-  blockHeight: number | null | undefined;
-  blockHash: string | null | undefined;
-  transactionSequenceNumber?: number;
-  accountId: string;
-  hasFailed?: boolean;
-  // --------------------------------------------- properties related to NFTs
-  standard?: NFTStandard | string;
-  operator?: string;
-  contract?: string;
-  tokenId?: string;
-  // --------------------------------------------- specific operation raw fields
-  date: string;
-  extra: Record<string, any>;
-  // would be a serializable version of the extra
-  subOperations?: OperationRaw[];
-  // in context of accounts that have internal transactions that belong to a parent transaction
-  // we have internal operations. Those are not included in the top level operations but can be presented to UI at that same level
-  internalOperations?: OperationRaw[];
-  // Operations related to ERC721 | ERC1155 tokens
-  nftOperations?: OperationRaw[];
-};

package/src/types/pagination.ts

@@ -1,19 +0,0 @@
-// A pagination config holds the user's pagination state
-// this is a state that usually should leave during the app lifecycle, but is not persisted
-// it drives the number of operations to poll in accounts
-// when a user paginate more, the number should accordingly be incremented
-// The UI should manage scrolling ahead of time (e.g. if 30 ops is displayed and UI have pages of 20 ops, the UI can already request to poll 70 ops so it have 2 pages in advance)
-// The UI must always do max() to keep the increasing the counter and not going back to lower value: that optim the sync to not recompute things too much
-export type PaginationConfig = {
-  // operations to pull for each account
-  operationsPerAccountId?: Record<string, number>;
-  // if define and there is no specific account in operationsPerAccountId,
-  // this will be the operations count used
-  operations?: number;
-};
-export type SyncConfig = {
-  paginationConfig: PaginationConfig;
-  // allows to disable the synchronization part – typically to only paginate more
-  withoutSynchronize?: boolean;
-  blacklistedTokenIds?: string[];
-};