@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/vechain/js-signOperation.ts

@@ -1,103 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-
-import type { Transaction } from "./types";
-import type { Account, Operation, SignOperationEvent } from "@ledgerhq/types-live";
-
-import { withDevice } from "../../hw/deviceAccess";
-import { encodeOperationId } from "../../operation";
-import { Transaction as ThorTransaction } from "thor-devkit";
-import Vet from "@ledgerhq/hw-app-vet";
-
-const buildOptimisticOperation = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<Operation> => {
-  const TYPE_OUT = "OUT";
-  const subAccountId = transaction.subAccountId;
-  const operation: Operation = {
-    id: encodeOperationId(account.id, "", TYPE_OUT),
-    hash: "",
-    type: subAccountId ? "NONE" : TYPE_OUT,
-    value: subAccountId ? new BigNumber(0) : new BigNumber(transaction.amount),
-    fee: subAccountId ? new BigNumber(0) : new BigNumber(transaction.estimatedFees),
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress],
-    recipients: [transaction.recipient].filter(Boolean),
-    accountId: account.id,
-    date: new Date(),
-    extra: {},
-    subOperations: subAccountId
-      ? [
-          {
-            id: encodeOperationId(subAccountId, "", "OUT"),
-            hash: "",
-            type: "OUT",
-            value: transaction.amount,
-            fee: subAccountId ? new BigNumber(transaction.estimatedFees) : new BigNumber(0),
-            blockHash: null,
-            blockHeight: null,
-            senders: [account.freshAddress],
-            recipients: [transaction.recipient].filter(Boolean),
-            accountId: subAccountId,
-            date: new Date(),
-            extra: {},
-          },
-        ]
-      : [],
-  };
-
-  return operation;
-};
-
-/**
- * Sign Transaction with Ledger hardware
- */
-const signOperation = ({
-  account,
-  deviceId,
-  transaction,
-}: {
-  account: Account;
-  deviceId: string;
-  transaction: Transaction;
-}): Observable<SignOperationEvent> =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        async function main() {
-          const unsigned = new ThorTransaction(transaction.body);
-
-          // Sign on device
-          const vechainApp = new Vet(transport);
-          o.next({
-            type: "device-signature-requested",
-          });
-          const signature = await vechainApp.signTransaction(
-            account.freshAddressPath,
-            unsigned.encode().toString("hex"),
-          );
-
-          o.next({ type: "device-signature-granted" });
-
-          const operation = await buildOptimisticOperation(account, transaction);
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature: signature.toString("hex"),
-              rawData: transaction,
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
-export default signOperation;

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

@@ -1,107 +0,0 @@
-import { Account } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
-import { DEFAULT_GAS_COEFFICIENT, HEX_PREFIX, MAINNET_CHAIN_TAG } from "./constants";
-import { Transaction } from "./types";
-import { Transaction as ThorTransaction } from "thor-devkit";
-import { calculateTransactionInfo, generateNonce } from "./utils/transaction-utils";
-import { VTHO_ADDRESS } from "./contracts/constants";
-import VIP180 from "./contracts/abis/VIP180";
-import { isValid } from "./utils/address-utils";
-import { getBlockRef } from "./api";
-
-/**
- * Create an empty VET or VTHO transaction
- *
- * @returns {Transaction}
- */
-export const createTransaction = (): Transaction => {
-  const chainTag = MAINNET_CHAIN_TAG;
-
-  return {
-    family: "vechain",
-    body: {
-      chainTag,
-      blockRef: "0x0000000000000000",
-      expiration: 18,
-      clauses: [],
-      gasPriceCoef: DEFAULT_GAS_COEFFICIENT,
-      gas: "0",
-      dependsOn: null,
-      nonce: generateNonce(),
-    },
-    amount: BigNumber(0),
-    estimatedFees: "0",
-    recipient: "",
-    useAllAmount: false,
-  };
-};
-
-/**
- * Prepare transaction before checking status
- *
- * @param {Account} a
- * @param {Transaction} t
- */
-export const prepareTransaction = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<Transaction> => {
-  const { amount, isTokenAccount, estimatedFees, estimatedGas } = await calculateTransactionInfo(
-    account,
-    transaction,
-  );
-
-  let blockRef = "";
-
-  let clauses: Array<ThorTransaction.Clause> = [];
-  if (transaction.recipient && isValid(transaction.recipient)) {
-    blockRef = await getBlockRef();
-    if (isTokenAccount) {
-      clauses = await calculateClausesVtho(transaction.recipient, amount);
-    } else {
-      clauses = await calculateClausesVet(transaction.recipient, amount);
-    }
-  }
-
-  const body = { ...transaction.body, gas: estimatedGas, blockRef, clauses };
-  return { ...transaction, body, amount, estimatedFees };
-};
-
-export const calculateClausesVtho = async (
-  recipient: string,
-  amount: BigNumber,
-): Promise<ThorTransaction.Clause[]> => {
-  const clauses: ThorTransaction.Clause[] = [];
-
-  // Get the existing clause or create a blank one
-  const updatedClause: ThorTransaction.Clause = {
-    to: VTHO_ADDRESS,
-    value: 0,
-    data: "0x",
-  };
-  updatedClause.data = VIP180.transfer.encode(recipient, amount.toFixed());
-
-  clauses.push(updatedClause);
-  return clauses;
-};
-
-export const calculateClausesVet = async (
-  recipient: string,
-  amount: BigNumber,
-): Promise<ThorTransaction.Clause[]> => {
-  const clauses: ThorTransaction.Clause[] = [];
-
-  // Get the existing clause or create a blank one
-  const updatedClause: ThorTransaction.Clause = {
-    to: null,
-    value: 0,
-    data: "0x",
-  };
-
-  updatedClause.value = `${HEX_PREFIX}${amount.toString(16)}`;
-  updatedClause.to = recipient;
-
-  clauses.push(updatedClause);
-
-  return clauses;
-};

package/src/market/MarketDataProvider.tsx

@@ -1,403 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-// @flow
-import React, {
-  createContext,
-  useCallback,
-  useContext,
-  ReactElement,
-  useReducer,
-  useEffect,
-} from "react";
-
-import { useDebounce } from "../hooks/useDebounce";
-import {
-  State,
-  MarketDataApi,
-  MarketListRequestParams,
-  MarketCurrencyChartDataRequestParams,
-  CurrencyData,
-  SingleCoinState,
-  SupportedCoins,
-} from "./types";
-import defaultFetchApi from "./api/api";
-import type { Currency } from "@ledgerhq/types-cryptoassets";
-type Props = {
-  children: React.ReactNode;
-  fetchApi?: MarketDataApi;
-  countervalue?: Currency;
-  initState?: Partial<State>;
-};
-type API = {
-  refresh: (param?: MarketListRequestParams) => void;
-  refreshChart: (param?: MarketCurrencyChartDataRequestParams) => void;
-  selectCurrency: (id?: string, data?: CurrencyData, range?: string) => void;
-  loadNextPage: (startIndex?: number, stopIndex?: number) => void | Promise<void>;
-  setCounterCurrency: (counterCurrency: string) => void;
-};
-
-export type MarketDataContextType = State & API;
-
-const initialState: State = {
-  ready: false,
-  marketData: [],
-  selectedCurrency: undefined,
-  requestParams: {
-    range: "24h",
-    limit: 50,
-    ids: [],
-    starred: [],
-    orderBy: "market_cap",
-    order: "desc",
-    search: "",
-    liveCompatible: false,
-  },
-  page: 1,
-  chartRequestParams: {
-    range: "24h",
-  },
-  loading: false,
-  loadingChart: false,
-  endOfList: false,
-  error: undefined,
-  totalCoinsAvailable: 0,
-  supportedCounterCurrencies: [],
-  selectedCoinData: undefined,
-  counterCurrency: undefined,
-};
-
-const MarketDataContext = createContext<MarketDataContextType>({
-  ...initialState,
-  refresh: () => {},
-  refreshChart: () => {},
-  selectCurrency: () => {},
-  loadNextPage: () => Promise.resolve(),
-  setCounterCurrency: () => {},
-});
-
-const ACTIONS = {
-  IS_READY: "IS_READY",
-
-  UPDATE_MARKET_DATA: "UPDATE_MARKET_DATA",
-  UPDATE_SINGLE_MARKET_DATA: "UPDATE_SINGLE_MARKET_DATA",
-  UPDATE_SINGLE_CHART_DATA: "UPDATE_SINGLE_CHART_DATA",
-
-  REFRESH_MARKET_DATA: "REFRESH_MARKET_DATA",
-  REFRESH_CHART_DATA: "REFRESH_CHART_DATA",
-
-  SET_LOADING: "SET_LOADING",
-  SET_LOADING_CHART: "SET_LOADING_CHART",
-  SET_ERROR: "SET_ERROR",
-
-  SELECT_CURRENCY: "SELECT_CURRENCY",
-  UPDATE_COUNTERVALUE: "UPDATE_COUNTERVALUE",
-};
-
-function marketDataReducer(state, action) {
-  switch (action.type) {
-    case ACTIONS.IS_READY:
-      return { ...state, ...action.payload, isReady: true };
-    case ACTIONS.UPDATE_MARKET_DATA: {
-      const newData = action.payload.marketData;
-      const page = action.payload.page || state.requestParams.page;
-      const marketData = [...state.marketData.map(data => ({ ...data }))];
-      if (!newData.length || marketData.some(({ id }) => id === newData[0].id))
-        return { ...state, loading: false };
-
-      return {
-        ...state,
-        marketData: marketData.concat(newData),
-        endOfList: newData.length < state.requestParams.limit,
-        loading: false,
-        page,
-      };
-    }
-    case ACTIONS.UPDATE_SINGLE_MARKET_DATA: {
-      return {
-        ...state,
-        selectedCoinData: { ...state.selectedCoinData, ...action.payload },
-        loading: false,
-      };
-    }
-    case ACTIONS.UPDATE_SINGLE_CHART_DATA: {
-      const chartRequestParams = {
-        ...state.chartRequestParams,
-        loadingChart: false,
-      };
-      const selectedCoinData = { ...state.selectedCoinData };
-
-      selectedCoinData.chartData = {
-        ...(selectedCoinData?.chartData ?? {}),
-        ...(action?.payload?.chartData ?? {}),
-      };
-
-      return { ...state, selectedCoinData, chartRequestParams };
-    }
-
-    case ACTIONS.REFRESH_MARKET_DATA: {
-      const requestParams = {
-        ...state.requestParams,
-        ...action.payload,
-        lastRequestTime: Date.now(),
-      };
-      return {
-        ...state,
-        marketData: [],
-        requestParams,
-        loading: true,
-        page: 1,
-      };
-    }
-    case ACTIONS.REFRESH_CHART_DATA: {
-      const chartRequestParams = {
-        ...state.chartRequestParams,
-        ...action.payload,
-        loadingChart: true,
-        lastRequestTime: Date.now(),
-      };
-      return { ...state, chartRequestParams };
-    }
-
-    case ACTIONS.UPDATE_COUNTERVALUE: {
-      const requestParams = {
-        ...state.requestParams,
-        lastRequestTime: Date.now(),
-        page: 1,
-        counterCurrency: action.payload,
-      };
-      const chartRequestParams = {
-        ...state.chartRequestParams,
-        lastRequestTime: Date.now(),
-        counterCurrency: action.payload,
-      };
-      return {
-        ...state,
-        counterCurrency: action.payload,
-        marketData: [],
-        requestParams,
-        chartRequestParams,
-        loading: true,
-      };
-    }
-
-    case ACTIONS.SET_LOADING:
-      return { ...state, loading: action.payload };
-    case ACTIONS.SET_LOADING_CHART:
-      return { ...state, loadingChart: action.payload };
-    case ACTIONS.SET_ERROR:
-      return { ...state, error: action.payload, loading: false };
-    case ACTIONS.SELECT_CURRENCY: {
-      const chartRequestParams = {
-        ...state.chartRequestParams,
-        counterCurrency: state.requestParams.counterCurrency,
-        range: action.payload.range || state.requestParams.range,
-        id: action.payload.id,
-        loadingChart: !!action.payload.id,
-        lastRequestTime: Date.now(),
-      };
-      return {
-        ...state,
-        selectedCurrency: action.payload.id,
-        selectedCoinData: action.payload.data,
-        loading: !!action.payload.id,
-        chartRequestParams,
-      };
-    }
-    default:
-      return state;
-  }
-}
-
-export const MarketDataProvider = ({
-  children,
-  fetchApi,
-  countervalue,
-  initState = {},
-}: Props): ReactElement => {
-  const [state, dispatch] = useReducer(marketDataReducer, {
-    ...initialState,
-    ...initState,
-  });
-  const api = fetchApi || defaultFetchApi;
-  const { requestParams, chartRequestParams, loading, loadingChart, page, selectedCoinData } =
-    useDebounce(state, 300);
-
-  const handleError = useCallback((payload: Error) => {
-    dispatch({ type: ACTIONS.SET_ERROR, payload });
-  }, []);
-
-  useEffect(() => {
-    if (countervalue) {
-      const ticker = countervalue.ticker.toLowerCase();
-      api.supportedCounterCurrencies().then(
-        supportedCounterCurrencies =>
-          api.setSupportedCoinsList().then((coins: SupportedCoins) => {
-            dispatch({
-              type: ACTIONS.IS_READY,
-              payload: {
-                totalCoinsAvailable: coins.length,
-                supportedCounterCurrencies,
-              },
-            });
-            dispatch({
-              type: ACTIONS.UPDATE_COUNTERVALUE,
-              payload: supportedCounterCurrencies.includes(ticker) ? ticker : "usd",
-            });
-          }, handleError),
-        handleError,
-      );
-    }
-  }, [api, countervalue, handleError]);
-
-  useEffect(() => {
-    if (chartRequestParams?.id && chartRequestParams?.counterCurrency && !loadingChart) {
-      const range = chartRequestParams.range;
-
-      if (selectedCoinData && !selectedCoinData?.chartData?.[range]) {
-        api.currencyChartData(chartRequestParams).then(
-          chartData =>
-            dispatch({
-              type: ACTIONS.UPDATE_SINGLE_CHART_DATA,
-              payload: { id: chartRequestParams.id, chartData },
-            }),
-          handleError,
-        );
-      } else
-        dispatch({
-          type: ACTIONS.SET_LOADING_CHART,
-          payload: false,
-        });
-    }
-  }, [chartRequestParams, selectedCoinData, api, handleError, loadingChart]);
-
-  useEffect(() => {
-    if (chartRequestParams?.id && chartRequestParams?.counterCurrency) {
-      dispatch({ type: ACTIONS.SET_LOADING, payload: true });
-      api
-        .listPaginated({
-          ...chartRequestParams,
-          search: "",
-          starred: [],
-          liveCompatible: false,
-          ids: [chartRequestParams.id],
-          limit: 1,
-          page: 1,
-        })
-        .then(([marketData]) => {
-          if (marketData) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { chartData, ...rest } = marketData;
-            dispatch({
-              type: ACTIONS.UPDATE_SINGLE_MARKET_DATA,
-              payload: rest,
-            });
-          }
-        }, handleError);
-    }
-  }, [api, chartRequestParams, handleError, loading]);
-
-  useEffect(() => {
-    if (requestParams?.counterCurrency) {
-      api.listPaginated(requestParams).then(
-        marketData =>
-          dispatch({
-            type: ACTIONS.UPDATE_MARKET_DATA,
-            payload: { marketData },
-          }),
-        handleError,
-      );
-    }
-  }, [api, handleError, requestParams]);
-
-  const refresh = useCallback((payload = {}) => {
-    dispatch({ type: ACTIONS.REFRESH_MARKET_DATA, payload });
-  }, []);
-
-  const refreshChart = useCallback((payload = {}) => {
-    dispatch({ type: ACTIONS.REFRESH_CHART_DATA, payload });
-  }, []);
-
-  const selectCurrency = useCallback((id, data, range) => {
-    dispatch({ type: ACTIONS.SELECT_CURRENCY, payload: { id, data, range } });
-  }, []);
-
-  const loadNextPage = useCallback(
-    () =>
-      new Promise((resolve, reject) => {
-        if (loading) {
-          reject(new Error());
-        } else {
-          const newPage = page + 1;
-          api.listPaginated({ ...requestParams, page: newPage }).then(
-            marketData => {
-              dispatch({
-                type: ACTIONS.UPDATE_MARKET_DATA,
-                payload: { marketData, page: newPage },
-              });
-              resolve(true);
-            },
-            err => {
-              handleError(err);
-              reject(new Error(err));
-            },
-          );
-        }
-      }),
-    [loading, page, api, requestParams, handleError],
-  );
-
-  const setCounterCurrency = useCallback(
-    payload => dispatch({ type: ACTIONS.UPDATE_COUNTERVALUE, payload }),
-    [dispatch],
-  );
-
-  const value = {
-    ...state,
-    refresh,
-    refreshChart,
-    selectCurrency,
-    loadNextPage,
-    setCounterCurrency,
-  };
-
-  return <MarketDataContext.Provider value={value}>{children}</MarketDataContext.Provider>;
-};
-
-export function useMarketData(): MarketDataContextType {
-  return useContext(MarketDataContext);
-}
-
-export type SingleCoinProviderData = SingleCoinState & {
-  selectCurrency: (id?: string, data?: CurrencyData, range?: string) => void;
-  refreshChart: (param?: MarketCurrencyChartDataRequestParams) => void;
-  setCounterCurrency: (counterCurrency: string) => void;
-};
-
-export function useSingleCoinMarketData(): SingleCoinProviderData {
-  const {
-    selectedCurrency,
-    selectedCoinData,
-    selectCurrency,
-    chartRequestParams,
-    loading,
-    loadingChart,
-    error,
-    counterCurrency,
-    refreshChart,
-    setCounterCurrency,
-    supportedCounterCurrencies,
-  } = useContext(MarketDataContext);
-
-  return {
-    selectedCurrency,
-    selectedCoinData,
-    selectCurrency,
-    chartRequestParams,
-    loading,
-    loadingChart,
-    error,
-    counterCurrency,
-    refreshChart,
-    setCounterCurrency,
-    supportedCounterCurrencies,
-  };
-}