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

package/src/market/hooks/useMarketDataProvider.ts

@@ -0,0 +1,144 @@
+import { UseQueryResult, useQueries, useQuery } from "@tanstack/react-query";
+import {
+  fetchCurrency,
+  fetchCurrencyChartData,
+  fetchList,
+  getSupportedCoinsList,
+  supportedCounterCurrencies,
+} from "../api";
+import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
+import { listTokens } from "@ledgerhq/cryptoassets/tokens";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+import { useMemo } from "react";
+import { listSupportedCurrencies } from "../../currencies";
+import { currencyFormatter, format } from "../utils/currencyFormatter";
+import { QUERY_KEY } from "../utils/queryKeys";
+import { REFETCH_TIME_ONE_MINUTE, BASIC_REFETCH, ONE_DAY } from "../utils/timers";
+import {
+  MarketCurrencyRequestParams,
+  MarketListRequestParams,
+  CurrencyData,
+  HashMapBody,
+  MarketItemResponse,
+  MarketListRequestResult,
+  Order,
+} from "../utils/types";
+
+const cryptoCurrenciesList = [...listCryptoCurrencies(), ...listTokens()];
+
+export function useMarketDataProvider() {
+  const supportedCurrenciesInLIve = listSupportedCurrencies();
+
+  const liveCompatibleIds: string[] = supportedCurrenciesInLIve
+    .map(({ id }: CryptoCurrency) => id)
+    .filter(Boolean);
+  const { data: supportedCounterCurrencies } = useSupportedCounterCurrencies();
+  const { data: supportedCurrencies } = useSupportedCurrencies();
+
+  const liveCoinsList = useMemo(
+    () =>
+      (supportedCurrencies || [])
+        ?.filter(({ id }) => liveCompatibleIds.includes(id))
+        .map(({ id }) => id),
+    [liveCompatibleIds, supportedCurrencies],
+  );
+
+  return {
+    supportedCounterCurrencies,
+    supportedCurrencies,
+    liveCoinsList,
+  };
+}
+
+export const useCurrencyChartData = ({ id, counterCurrency, range }: MarketCurrencyRequestParams) =>
+  useQuery({
+    queryKey: [QUERY_KEY.CurrencyChartData, id, counterCurrency, range],
+    queryFn: () => fetchCurrencyChartData({ counterCurrency, range, id }),
+    refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
+    staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
+  });
+
+export const useCurrencyData = ({ id, counterCurrency }: MarketCurrencyRequestParams) =>
+  useQuery({
+    queryKey: [QUERY_KEY.CurrencyDataRaw, id, counterCurrency],
+    queryFn: () => fetchCurrency({ id, counterCurrency }),
+    refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
+    staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
+    select: data => format(data, cryptoCurrenciesList),
+  });
+
+export const useSupportedCounterCurrencies = () =>
+  useQuery({
+    queryKey: [QUERY_KEY.SupportedCounterCurrencies],
+    queryFn: () => supportedCounterCurrencies(),
+    refetchOnWindowFocus: true,
+    staleTime: ONE_DAY,
+  });
+
+export const useSupportedCurrencies = () =>
+  useQuery({
+    queryKey: [QUERY_KEY.SupportedCurrencies],
+    queryFn: () => getSupportedCoinsList(),
+    refetchOnWindowFocus: true,
+    staleTime: ONE_DAY,
+  });
+
+export function useMarketData(props: MarketListRequestParams): MarketListRequestResult {
+  return useQueries({
+    queries: Array.from({ length: props.page ?? 1 }, (_, i) => i).map(page => ({
+      queryKey: [
+        QUERY_KEY.MarketData,
+        page,
+        props.order,
+        {
+          counterCurrency: props.counterCurrency,
+          ...(props.search && props.search?.length >= 1 && { search: props.search }),
+          ...(props.starred && props.starred?.length >= 1 && { starred: props.starred }),
+          ...(props.liveCoinsList &&
+            props.liveCoinsList?.length >= 1 && { liveCoinsList: props.liveCoinsList }),
+          ...(props.order &&
+            [Order.topLosers, Order.topGainers].includes(props.order) && { range: props.range }),
+        },
+      ],
+      queryFn: () => fetchList({ ...props, page }),
+      select: (data: MarketItemResponse[]) => ({
+        formattedData: currencyFormatter(data, cryptoCurrenciesList),
+        page,
+      }),
+      refetchOnMount: false,
+      refetchOnReconnect: false,
+      refetchOnWindowFocus: false,
+    })),
+    combine: combineMarketData,
+  });
+}
+
+function combineMarketData(
+  results: UseQueryResult<
+    {
+      formattedData: CurrencyData[];
+      page: number;
+    },
+    Error
+  >[],
+) {
+  const hashMap = new Map<string, HashMapBody>();
+
+  results.forEach(result => {
+    if (result.data) {
+      hashMap.set(String(result.data.page), {
+        updatedAt: result.dataUpdatedAt,
+        refetch: result.refetch,
+      });
+    }
+  });
+
+  return {
+    data: results.flatMap(result => result.data?.formattedData ?? []),
+    isPending: results.some(result => result.isPending),
+    isLoading: results.some(result => result.isLoading),
+    isError: results.some(result => result.isError),
+    cachedMetadataMap: hashMap,
+  };
+}

package/src/market/hooks/useMarketPerformers.ts

@@ -0,0 +1,23 @@
+import { fetchMarketPerformers } from "../api";
+import { MarketItemPerformer, MarketItemResponse, MarketPerformersParams } from "../utils/types";
+import { QUERY_KEY } from "../utils/queryKeys";
+import { UseQueryResult, useQuery } from "@tanstack/react-query";
+import { formatPerformer } from "../utils/currencyFormatter";
+import { REFETCH_TIME_ONE_MINUTE } from "../utils/timers";
+
+export const useMarketPerformers = ({
+  counterCurrency,
+  range,
+  limit = 5,
+  top = 50,
+  sort,
+  supported,
+  refreshRate,
+}: MarketPerformersParams): UseQueryResult<MarketItemPerformer[], Error> =>
+  useQuery({
+    queryKey: [QUERY_KEY.MarketPerformers, counterCurrency, range, sort],
+    queryFn: () => fetchMarketPerformers({ counterCurrency, range, limit, top, sort, supported }),
+    refetchInterval: REFETCH_TIME_ONE_MINUTE * Number(refreshRate),
+    staleTime: REFETCH_TIME_ONE_MINUTE * Number(refreshRate),
+    select: data => data.map((currency: MarketItemResponse) => formatPerformer(currency)),
+  });

package/src/market/utils/currencyFormatter.ts

@@ -1,11 +1,11 @@
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   CurrencyData,
+  KeysPriceChange,
   MarketItemPerformer,
   MarketItemResponse,
-  RawCurrencyData,
   SparklineSvgData,
-} from "../types";
+} from "./types";
 
 function distributedCopy(items: number[], n: number): number[] {
   if (!items) return [];
@@ -46,42 +46,46 @@ function sparklineAsSvgData(points: number[]): SparklineSvgData {
 }
 
 export function currencyFormatter(
-  data: RawCurrencyData[],
-  range: string,
+  data: MarketItemResponse[],
   cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
 ): CurrencyData[] {
-  return data.map((currency: RawCurrencyData) => format(currency, range, cryptoCurrenciesList));
+  return data.map((currency: MarketItemResponse) => format(currency, cryptoCurrenciesList));
 }
 
 export const format = (
-  currency: RawCurrencyData,
-  range: string,
+  currency: MarketItemResponse,
   cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
-) => ({
+): CurrencyData => ({
   id: currency.id,
   name: currency.name,
-  image: typeof currency.image === "string" ? currency.image : currency.image?.thumb,
+  image: currency.image,
   internalCurrency: cryptoCurrenciesList.find(
-    ({ ticker }) => ticker.toLowerCase() === currency.symbol,
+    ({ ticker }) => ticker.toLowerCase() === currency.ticker,
   ),
-  marketcap: currency.market_cap,
-  marketcapRank: currency.market_cap_rank,
-  totalVolume: currency.total_volume,
-  high24h: currency.high_24h,
-  low24h: currency.low_24h,
-  ticker: currency.symbol,
-  price: currency.current_price,
-  priceChangePercentage: currency[`price_change_percentage_${range}_in_currency`],
-  marketCapChangePercentage24h: currency.market_cap_change_percentage_24h,
-  circulatingSupply: currency.circulating_supply,
-  totalSupply: currency.total_supply,
-  maxSupply: currency.max_supply,
-  ath: currency.ath,
-  athDate: currency.ath_date,
-  atl: currency.atl,
-  atlDate: currency.atl_date,
-  sparklineIn7d: currency?.sparkline_in_7d?.price
-    ? sparklineAsSvgData(distributedCopy(currency.sparkline_in_7d.price, 6 * 7)) // keep 6 points per day
+  marketcap: currency.marketCap,
+  marketcapRank: currency.marketCapRank,
+  totalVolume: currency.totalVolume,
+  high24h: currency.high24h,
+  low24h: currency.low24h,
+  ticker: currency.ticker,
+  price: currency.price,
+  priceChangePercentage: {
+    [KeysPriceChange.hour]: currency.priceChangePercentage1h,
+    [KeysPriceChange.day]: currency.priceChangePercentage24h,
+    [KeysPriceChange.week]: currency.priceChangePercentage7d,
+    [KeysPriceChange.month]: currency.priceChangePercentage30d,
+    [KeysPriceChange.year]: currency.priceChangePercentage1y,
+  },
+  marketCapChangePercentage24h: currency.marketCapChangePercentage24h,
+  circulatingSupply: currency.circulatingSupply,
+  totalSupply: currency.totalSupply,
+  maxSupply: currency.maxSupply,
+  ath: currency.allTimeHigh,
+  athDate: new Date(currency.allTimeHighDate),
+  atl: currency.allTimeLow,
+  atlDate: new Date(currency.allTimeLowDate),
+  sparklineIn7d: currency.sparkline
+    ? sparklineAsSvgData(distributedCopy(currency.sparkline, 6 * 7)) // keep 6 points per day
     : undefined,
   chartData: {},
 });

package/src/market/utils/index.ts

@@ -0,0 +1,34 @@
+import { PortfolioRange } from "@ledgerhq/types-live";
+import { Order } from "./types";
+
+export function getRange(range: PortfolioRange | string) {
+  switch (range) {
+    case "day":
+    case "24h":
+      return "1d";
+    case "7d":
+    case "week":
+      return "1w";
+    case "30d":
+    case "month":
+      return "1m";
+    case "1y":
+    case "year":
+    case "all":
+      return "1y";
+  }
+}
+
+export const getSortParam = (order: Order, range: PortfolioRange | string) => {
+  switch (order) {
+    default:
+    case Order.MarketCapDesc:
+      return "market-cap-rank";
+    case Order.MarketCapAsc:
+      return "market-cap-rank-desc";
+    case Order.topLosers:
+      return `negative-price-change-${getRange(range)}`;
+    case Order.topGainers:
+      return `positive-price-change-${getRange(range)}`;
+  }
+};

package/src/market/utils/types.ts

@@ -0,0 +1,190 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { RefetchOptions, QueryObserverResult } from "@tanstack/react-query";
+import { PortfolioRange } from "@ledgerhq/types-live";
+
+export type MarketCoin = {
+  id: string;
+  name: string;
+  symbol: string;
+};
+
+export type ChartDataPoint = [number, number];
+export type MarketCoinDataChart = Record<string, Array<ChartDataPoint>>;
+
+export enum Order {
+  MarketCapDesc = "desc",
+  MarketCapAsc = "asc",
+  topLosers = "topLosers",
+  topGainers = "topGainers",
+}
+
+export type SupportedCoins = MarketCoin[];
+
+export type MarketListRequestParams = {
+  counterCurrency?: string;
+  starred?: string[];
+  page?: number;
+  limit?: number;
+  range?: string;
+  order?: Order;
+  search?: string;
+  lastRequestTime?: Date;
+  liveCompatible?: boolean;
+  liveCoinsList?: string[];
+};
+
+export type MarketListRequestResult = {
+  data: CurrencyData[];
+  isPending: boolean;
+  isLoading: boolean;
+  isError: boolean;
+  cachedMetadataMap: Map<string, HashMapBody>;
+};
+
+export type HashMapBody = {
+  updatedAt: number;
+  refetch: (options?: RefetchOptions | undefined) => Promise<
+    QueryObserverResult<
+      {
+        formattedData: CurrencyData[];
+        page: number;
+      },
+      Error
+    >
+  >;
+};
+
+export type MarketCurrencyChartDataRequestParams = {
+  id?: string;
+  counterCurrency?: string;
+  range?: string;
+  lastRequestTime?: Date;
+};
+
+export type MarketCurrencyRequestParams = {
+  id?: string;
+  counterCurrency?: string;
+  range?: string;
+};
+
+export type SparklineSvgData = {
+  path: string;
+  viewBox: string;
+  isPositive: boolean;
+};
+
+export enum KeysPriceChange {
+  hour = "1h",
+  day = "24h",
+  week = "7d",
+  month = "30d",
+  year = "1y",
+}
+
+export type CurrencyData = {
+  id: string;
+  name: string;
+  image?: string;
+  internalCurrency?: CryptoOrTokenCurrency;
+  marketcap?: number;
+  marketcapRank: number;
+  totalVolume: number;
+  high24h: number;
+  low24h: number;
+  ticker: string;
+  price: number;
+  priceChangePercentage: Record<KeysPriceChange, number>;
+  marketCapChangePercentage24h: number;
+  circulatingSupply: number;
+  totalSupply: number;
+  maxSupply: number;
+  ath: number;
+  athDate: Date;
+  atl: number;
+  atlDate: Date;
+  sparklineIn7d?: SparklineSvgData;
+  chartData: MarketCoinDataChart;
+};
+
+export type SingleCoinState = {
+  selectedCurrency?: string;
+  chartRequestParams: MarketCurrencyChartDataRequestParams;
+  loading: boolean;
+  loadingChart: boolean;
+  error?: Error;
+  supportedCounterCurrencies: string[];
+  selectedCoinData?: CurrencyData;
+  counterCurrency?: string;
+};
+
+export type State = SingleCoinState & {
+  ready: boolean;
+  marketData?: CurrencyData[];
+  requestParams: MarketListRequestParams;
+  page: number;
+  endOfList: boolean;
+  totalCoinsAvailable: number;
+};
+
+export type MarketPerformersParams = {
+  limit: number;
+  top: number;
+  sort: "asc" | "desc";
+  range: PortfolioRange;
+  counterCurrency: string;
+  supported: boolean;
+  refreshRate?: number;
+};
+
+export type MarketItemResponse = {
+  allTimeHigh: number;
+  allTimeHighDate: string;
+  allTimeLow: number;
+  allTimeLowDate: string;
+  circulatingSupply: number;
+  fullyDilutedValuation: number;
+  high24h: number;
+  id: string;
+  image: string;
+  ledgerIds: string[];
+  low24h: number;
+  marketCap: number;
+  marketCapChange24h: number;
+  marketCapChangePercentage24h: number;
+  marketCapRank: number;
+  maxSupply: number;
+  name: string;
+  price: number;
+  priceChange24h: number;
+  priceChangePercentage1h: number;
+  priceChangePercentage24h: number;
+  priceChangePercentage30d: number;
+  priceChangePercentage7d: number;
+  priceChangePercentage1y: number;
+  sparkline: number[];
+  ticker: string;
+  totalSupply: number;
+  totalVolume: number;
+  updatedAt: string;
+};
+export type MarketItemPerformer = {
+  name: string;
+  ticker: string;
+  priceChangePercentage1h: number;
+  priceChangePercentage24h: number;
+  priceChangePercentage7d: number;
+  priceChangePercentage30d: number;
+  priceChangePercentage1y: number;
+  image: string;
+  price: number;
+  ledgerIds: string[];
+};
+
+export type MarketDataApi = {
+  setSupportedCoinsList: () => Promise<SupportedCoins>;
+  listPaginated: (params: MarketListRequestParams) => Promise<CurrencyData[]>;
+  supportedCounterCurrencies: () => Promise<string[]>;
+  currencyChartData: (
+    params: MarketCurrencyChartDataRequestParams,
+  ) => Promise<{ [range: string]: number[][] }>;
+};

package/src/platform/converters.ts

@@ -1,9 +1,10 @@
-import { FAMILIES } from "@ledgerhq/live-app-sdk";
 import { Account, AccountLike } from "@ledgerhq/types-live";
 import { isTokenAccount } from "../account";
 import byFamily from "../generated/platformAdapter";
 import type { Transaction } from "../generated/types";
 import {
+  FAMILIES_MAPPING_LL_TO_PLATFORM,
+  FAMILIES_MAPPING_PLATFORM_TO_LL,
   PlatformAccount,
   PlatformCurrency,
   PlatformCurrencyType,
@@ -75,7 +76,7 @@ export function currencyToPlatformCurrency(currency: PlatformSupportedCurrency):
     id: currency.id,
     ticker: currency.ticker,
     name: currency.name,
-    family: currency.family,
+    family: FAMILIES_MAPPING_LL_TO_PLATFORM[currency.family] ?? currency.family,
     color: currency.color,
     units: currency.units.map(unit => ({
       name: unit.name,
@@ -92,9 +93,7 @@ export const getPlatformTransactionSignFlowInfos = (
   hasFeesProvided: boolean;
   liveTx: Partial<Transaction>;
 } => {
-  // This is a hack to link WalletAPI "ethereum" family to new "evm" family
-  const isEthereumFamily = platformTx.family === FAMILIES.ETHEREUM;
-  const liveFamily = isEthereumFamily ? "evm" : platformTx.family;
+  const liveFamily = FAMILIES_MAPPING_PLATFORM_TO_LL[platformTx.family] ?? platformTx.family;
 
   const familyModule = byFamily[liveFamily];
 

package/src/platform/types.ts

@@ -7,6 +7,14 @@ import {
   FAMILIES,
 } from "@ledgerhq/live-app-sdk";
 import { z } from "zod";
+import { reverseRecord } from "../helpers";
+
+export const FAMILIES_MAPPING_PLATFORM_TO_LL = {
+  ethereum: "evm",
+  ripple: "xrp",
+} as const;
+
+export const FAMILIES_MAPPING_LL_TO_PLATFORM = reverseRecord(FAMILIES_MAPPING_PLATFORM_TO_LL);
 
 /**
  * this is a hack to add the "evm" family to the list of supported families of
@@ -15,7 +23,10 @@ import { z } from "zod";
  * "ethereum" family, following the "ethereum" / "evm" families merge
  * (and removal of the "ethereum" family)
  */
-export const PLATFORM_FAMILIES = [...Object.values(FAMILIES), "evm", "xrp"];
+export const PLATFORM_FAMILIES = [
+  ...Object.values(FAMILIES),
+  ...Object.values(FAMILIES_MAPPING_PLATFORM_TO_LL),
+];
 
 export { FAMILIES as PLATFORM_FAMILIES_ENUM };
 

package/src/wallet-api/constants.ts

@@ -2,13 +2,21 @@ import Fuse from "fuse.js";
 import { AppManifest } from "../wallet-api/types";
 
 import { FAMILIES } from "@ledgerhq/wallet-api-core";
+import { reverseRecord } from "../helpers";
+
+export const FAMILIES_MAPPING_WAPI_TO_LL = {
+  ethereum: "evm",
+  ripple: "xrp",
+} as const;
+
+export const FAMILIES_MAPPING_LL_TO_WAPI = reverseRecord(FAMILIES_MAPPING_WAPI_TO_LL);
 
 /**
  * FIXME
  * This is not robust, we should have an explicit adapter between the wallet API currencies (families) and live currencies (families)
  * For example here, the `ethereum` family on `wallet-api` should be mapped to the `evm` family on LL
  */
-export const WALLET_API_FAMILIES = [...FAMILIES, "evm", "xrp"];
+export const WALLET_API_FAMILIES = [...FAMILIES, ...Object.values(FAMILIES_MAPPING_WAPI_TO_LL)];
 
 export const WALLET_API_VERSION = "2.0.0";
 

package/src/wallet-api/converters.ts

@@ -1,5 +1,6 @@
 import { Account, AccountLike } from "@ledgerhq/types-live";
 import { v5 as uuidv5 } from "uuid";
+import { WalletState, accountNameWithDefaultSelector } from "@ledgerhq/live-wallet/store";
 import byFamily from "../generated/walletApiAdapter";
 import type { Transaction } from "../generated/types";
 import { isTokenAccount } from "../account";
@@ -10,8 +11,7 @@ import {
   WalletAPISupportedCurrency,
   GetWalletAPITransactionSignFlowInfos,
 } from "./types";
-import { Families } from "@ledgerhq/wallet-api-core";
-import { WalletState, accountNameWithDefaultSelector } from "@ledgerhq/live-wallet/store";
+import { FAMILIES_MAPPING_LL_TO_WAPI, FAMILIES_MAPPING_WAPI_TO_LL } from "./constants";
 
 // The namespace is a randomly generated uuid v4 from https://www.uuidgenerator.net/
 const NAMESPACE = "c3c78073-6844-409e-9e75-171ab4c7f9a2";
@@ -86,7 +86,7 @@ export function currencyToWalletAPICurrency(
     id: currency.id,
     ticker: currency.ticker,
     name: currency.name,
-    family: currency.family === "evm" ? "ethereum" : (currency.family as Families),
+    family: FAMILIES_MAPPING_LL_TO_WAPI[currency.family] ?? currency.family,
     color: currency.color,
     decimals: currency.units[0].magnitude,
   };
@@ -96,9 +96,8 @@ export const getWalletAPITransactionSignFlowInfos: GetWalletAPITransactionSignFl
   WalletAPITransaction,
   Transaction
 > = ({ walletApiTransaction, account }) => {
-  // This is a hack to link WalletAPI "ethereum" family to new "evm" family
-  const isEthereumFamily = walletApiTransaction.family === "ethereum";
-  const liveFamily = isEthereumFamily ? "evm" : walletApiTransaction.family;
+  const liveFamily =
+    FAMILIES_MAPPING_WAPI_TO_LL[walletApiTransaction.family] ?? walletApiTransaction.family;
 
   const familyModule = byFamily[liveFamily];
 

package/src/wallet-api/useDappLogic.ts

@@ -95,7 +95,8 @@ function useDappAccountLogic({
   currentAccountHistDb?: CurrentAccountHistDB;
 }) {
   const { currencyIds } = usePermission(manifest);
-  const { currentAccount, setCurrentAccount } = useDappCurrentAccount(currentAccountHistDb);
+  const { currentAccount, setCurrentAccount, setCurrentAccountHist } =
+    useDappCurrentAccount(currentAccountHistDb);
   const currentParentAccount = useMemo(() => {
     if (currentAccount) {
       return getParentAccount(currentAccount, accounts);
@@ -156,6 +157,7 @@ function useDappAccountLogic({
     currentAccount,
     setCurrentAccount,
     currentParentAccount,
+    setCurrentAccountHist,
   };
 }
 
@@ -188,7 +190,7 @@ export function useDappLogic({
 }) {
   const nanoApp = manifest.dapp?.nanoApp;
   const ws = useRef<SmartWebsocket>();
-  const { currentAccount, currentParentAccount } = useDappAccountLogic({
+  const { currentAccount, currentParentAccount, setCurrentAccountHist } = useDappAccountLogic({
     manifest,
     accounts,
     currentAccountHistDb,
@@ -386,7 +388,8 @@ export function useDappLogic({
             await new Promise<void>((resolve, reject) =>
               uiHook["account.request"]({
                 currencies: [getCryptoCurrencyById(requestedCurrency.currency)],
-                onSuccess: () => {
+                onSuccess: account => {
+                  setCurrentAccountHist(manifest.id, account);
                   resolve();
                 },
                 onCancel: () => {

package/lib/families/celo/js-broadcast.d.ts

@@ -1,8 +0,0 @@
-declare const broadcast: ({ signedOperation: { operation, signature } }: {
-    signedOperation: {
-        operation: any;
-        signature: any;
-    };
-}) => Promise<import("@ledgerhq/types-live").Operation>;
-export default broadcast;
-//# sourceMappingURL=js-broadcast.d.ts.map

package/lib/families/celo/js-broadcast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-broadcast.d.ts","sourceRoot":"","sources":["../../../src/families/celo/js-broadcast.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,SAAS;;;;;uDAId,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/lib/families/celo/js-broadcast.js

@@ -1,20 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const operation_1 = require("../../operation");
-const sdk_1 = require("./api/sdk");
-const broadcast = ({ signedOperation: { operation, signature } }) => __awaiter(void 0, void 0, void 0, function* () {
-    const kit = (0, sdk_1.celoKit)();
-    const { transactionHash } = yield kit.web3.eth.sendSignedTransaction(signature);
-    return (0, operation_1.patchOperationWithHash)(operation, transactionHash);
-});
-exports.default = broadcast;
-//# sourceMappingURL=js-broadcast.js.map

package/lib/families/celo/js-broadcast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-broadcast.js","sourceRoot":"","sources":["../../../src/families/celo/js-broadcast.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,+CAAyD;AACzD,mCAAoC;AAEpC,MAAM,SAAS,GAAG,CAAO,EAAE,eAAe,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE;IACxE,MAAM,GAAG,GAAG,IAAA,aAAO,GAAE,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAChF,OAAO,IAAA,kCAAsB,EAAC,SAAS,EAAE,eAAe,CAAC,CAAC;AAC5D,CAAC,CAAA,CAAC;AAEF,kBAAe,SAAS,CAAC"}

package/lib/families/celo/js-buildTransaction.d.ts

@@ -1,4 +0,0 @@
-import type { CeloAccount, Transaction } from "./types";
-declare const buildTransaction: (account: CeloAccount, transaction: Transaction) => Promise<any>;
-export default buildTransaction;
-//# sourceMappingURL=js-buildTransaction.d.ts.map