@otoplo/wallet-common 0.1.15 → 0.2.0

package/src/services/wallet.ts

@@ -193,11 +193,10 @@ export class WalletManager {
     await this.subscribeAddresses(this.getAllAddresses(), true);
 
     const tokensLoadPromises: Promise<void>[] = [];
-    tokensLoadPromises.push(this.assetService.fetchAndSaveTokens(MAIN_WALLET_ID, sumTokensBalance(this.getMainAddresses().map(a => a.tokensBalance))));
+    tokensLoadPromises.push(this.assetService.syncTokens(MAIN_WALLET_ID, sumTokensBalance(this.getMainAddresses().map(a => a.tokensBalance))));
     for (const account of this.accounts.values()) {
-      tokensLoadPromises.push(this.assetService.fetchAndSaveTokens(account.id, account.tokensBalance));
+      tokensLoadPromises.push(this.assetService.syncTokens(account.id, account.tokensBalance));
     }
-
     await Promise.all(tokensLoadPromises);
   }
 
@@ -219,7 +218,6 @@ export class WalletManager {
         address: this.getReceiveAddress(),
         balance: sumBalance(walletAddresses.map(a => a.balance)),
         tokensBalance: sumTokensBalance(walletAddresses.map(a => a.tokensBalance)),
-        tokens: [],
         sessions: {}
       }
     });
@@ -233,7 +231,6 @@ export class WalletManager {
           address: account.address,
           balance: account.balance,
           tokensBalance: account.tokensBalance,
-          tokens: [],
           sessions: {}
         }
       });
@@ -401,7 +398,7 @@ export class WalletManager {
         }
       }
 
-      await Promise.all([this.postProcessWalletUpdate(walletTxs), this.postProcessAccountUpdate(accountsTxs)]);
+      await Promise.all([this.postProcessWalletUpdate(walletTxs), this.postProcessAccountsUpdate(accountsTxs)]);
     } catch (e) {
       console.error('Error processing pending updates:', e);
     } finally {
@@ -431,29 +428,35 @@ export class WalletManager {
     this.notify({ type: 'account_balance_updated', accountId: MAIN_WALLET_ID, balance: walletBalance, tokensBalance: walletTokenBalances });
     this.notify({ type: 'main_address_updated', address: this.getReceiveAddress() });
 
-    const nftPromise = this.assetService.syncNfts(MAIN_WALLET_ID, walletTokenBalances);
-    for (const tx of txHistoryMap.values()) {
-      await this.transactionService.classifyAndSaveTransaction(MAIN_WALLET_ID, tx.tx_hash, walletAddresses.map(a => a.address));
-    }
-    await nftPromise;
+    await this.postProcessActivity(MAIN_WALLET_ID, Array.from(txHistoryMap.values()), walletAddresses.map(a => a.address), walletTokenBalances);
   }
 
-  private async postProcessAccountUpdate(history: AddressHistory[]): Promise<void> {
+  private async postProcessAccountsUpdate(history: AddressHistory[]): Promise<void> {
     if (history.length === 0) {
       return;
     }
 
+    const activityPromises: Promise<void>[] = [];
     for (const { address, txs } of history) {
       const account = address as AccountDTO;
       
       this.notify({ type: 'account_balance_updated', accountId: account.id, balance: account.balance, tokensBalance: account.tokensBalance });
 
-      const nftPromise = this.assetService.syncNfts(account.id, account.tokensBalance);
-      for (const tx of txs) {
-        await this.transactionService.classifyAndSaveTransaction(account.id, tx.tx_hash, [account.address]);
-      }
-      await nftPromise;
+      const p = this.postProcessActivity(account.id, txs, [account.address], account.tokensBalance);
+      activityPromises.push(p);
+    }
+    await Promise.all(activityPromises);
+  }
+
+  private async postProcessActivity(accountId: number, txHistory: ITXHistory[], addresses: string[], tokensBalance: Record<string, Balance>): Promise<void> {
+    const postPromises: Promise<void>[] = [];
+    const nftPromise = this.assetService.syncNfts(accountId, tokensBalance);
+    for (const tx of txHistory) {
+      const p = this.transactionService.classifyAndSaveTransaction(accountId, tx.tx_hash, addresses);
+      postPromises.push(p);
     }
+    postPromises.push(nftPromise);
+    await Promise.all(postPromises);
   }
 
   private async fetchAndUpdateAddress(addrDTO: AddressDTO, hash: string): Promise<AddressHistory> {
@@ -544,7 +547,6 @@ export class WalletManager {
     this.accounts.set(id, account);
     this.accountsAddressToId.set(address, id);
     await this.walletDb.saveAccount(account);
-    await this.subscribeAddresses([account]);
 
     this.notify({
       type: 'new_account',
@@ -554,10 +556,10 @@ export class WalletManager {
         address: account.address,
         balance: account.balance,
         tokensBalance: account.tokensBalance,
-        tokens: [],
         sessions: {}
       }
     });
+    await this.subscribeAddresses([account]);
   }
 
   public async updateAccountName(id: number, name: string): Promise<void> {
@@ -609,8 +611,7 @@ export class WalletManager {
   private async addVault(vault: VaultDTO): Promise<void> {
     this.vaults.set(vault.address, vault);
     await this.walletDb.saveVault(vault);
-    await this.subscribeAddresses([vault]);
-
+    
     this.notify({
       type: 'new_vault',
       vault: {
@@ -620,6 +621,7 @@ export class WalletManager {
         index: vault.idx
       }
     });
+    await this.subscribeAddresses([vault]);
   }
 
   public async rescanVaults(): Promise<boolean> {

package/src/state/hooks.ts

@@ -2,12 +2,14 @@ import { useSelector } from "react-redux";
 import type { SharedState } from "./store";
 import { createSelector } from "@reduxjs/toolkit";
 import type { AuthState } from "./slices";
-import type { Account, AppNotification, Balance, SessionInfo, VaultInfo } from "../types";
+import type { Account, AppNotification, Balance, MarketData, SessionInfo, VaultInfo } from "../types";
 
 const useSharedSelector = useSelector.withTypes<SharedState>();
 
 export const useAuth = (): AuthState => useSharedSelector(state => state.auth);
 
+export const useMarketData = (tokenId: string): MarketData => useSharedSelector(state => state.market.data[tokenId]);
+
 export const useBlockHeight = (): number => useSharedSelector(state => state.status.height);
 
 export const useAccount = (id: number): Account => useSharedSelector(state => state.wallet.accounts[id]);

package/src/state/slices/market.ts

@@ -0,0 +1,47 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
+import type { MarketData } from "../../types";
+import type { CurrencyCode} from "../../utils";
+import { getMarketData } from "../../utils";
+import type { SharedState } from "../store";
+
+export interface MarketState {
+  currency: CurrencyCode;
+  data: Record<string, MarketData>;
+}
+
+const initialState: MarketState = {
+  currency: 'usd',
+  data: {}
+};
+
+const updateMarketData = createAsyncThunk('market/updateMarketData', async (_, thunkAPI) => {
+  const state = thunkAPI.getState() as SharedState;
+  return await getMarketData(state.market.currency);
+});
+
+const marketSlice = createSlice({
+  name: 'market',
+  initialState,
+  reducers: {
+    setCurrency: (state, action: PayloadAction<CurrencyCode>) => {
+      state.currency = action.payload;
+    },
+    setMarketData: (state, action: PayloadAction<Record<string, MarketData>>) => {
+      state.data = action.payload;
+    }
+  },
+  extraReducers: (builder) => {
+    builder
+      .addCase(updateMarketData.fulfilled, (state, action) => {
+        state.data = action.payload;
+      })
+      .addCase(updateMarketData.rejected, (_, action) => {
+        console.error(action.error.message);
+      });
+  }
+});
+
+export const marketThunks = { updateMarketData };
+export const marketActions = marketSlice.actions;
+export const marketReducer = marketSlice.reducer;

package/src/state/slices/status.ts

@@ -1,12 +1,9 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
-import type { Price } from "../../types";
-import { getNexaPrices, initializePrices } from "../../utils";
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
 
 export interface StatusState {
   status: "Online" | "Offline";
   height: number;
-  price: Record<string, Price>;
   hasNetwork: boolean;
   isSuspended: boolean;
 }
@@ -14,27 +11,10 @@ export interface StatusState {
 const initialState: StatusState = {
   status: "Offline",
   height: 0,
-  price: initializePrices(),
   hasNetwork: true,
   isSuspended: false,
 };
 
-export const fetchPrice = createAsyncThunk('status/fetchPrice', async () => {
-  const prices = initializePrices();
-  try {
-    const p = await getNexaPrices();
-    Object.keys(p).forEach(currency => {
-      prices[currency] = { 
-        value: p[currency],
-        change: p[`${currency}_24h_change`]
-      };
-    });
-  } catch {
-    // prices remain at 0
-  }
-  return prices ;
-});
-
 const statusSlice = createSlice({
   name: 'status',
   initialState,
@@ -54,15 +34,6 @@ const statusSlice = createSlice({
     setIsSuspended: (state, action: PayloadAction<boolean>) => {
       state.isSuspended = action.payload;
     }
-  },
-  extraReducers: (builder) => {
-    builder
-      .addCase(fetchPrice.fulfilled, (state, action) => {
-        state.price = action.payload;
-      })
-      .addCase(fetchPrice.rejected, (_, action) => {
-        console.error(action.error.message);
-      });
   }
 });
 

package/src/state/slices/wallet.ts

@@ -1,6 +1,6 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
+import type { PayloadAction } from "@reduxjs/toolkit";
 import { createSlice } from "@reduxjs/toolkit";
-import type { Account, AssetEntity, Balance, SessionInfo, VaultInfo } from "../../types";
+import type { Account, Balance, SessionInfo, VaultInfo } from "../../types";
 import { MAIN_WALLET_ID } from "../../utils";
 
 interface AddSessionPayload {
@@ -22,6 +22,7 @@ export interface WalletState {
   initLoad: boolean;
   txUpdateTrigger: number;
   nftsUpdateTrigger: number;
+  tokensUpdateTrigger: number;
 }
 
 const initialState: WalletState = {
@@ -34,7 +35,6 @@ const initialState: WalletState = {
       address: '',
       balance: {confirmed: "0", unconfirmed: "0"},
       tokensBalance: {},
-      tokens: [],
       sessions: {}
     }
   },
@@ -42,7 +42,8 @@ const initialState: WalletState = {
   sync: false,
   initLoad: true,
   txUpdateTrigger: 0,
-  nftsUpdateTrigger: 0
+  nftsUpdateTrigger: 0,
+  tokensUpdateTrigger: 0
 }
 
 const walletSlice = createSlice({
@@ -77,21 +78,15 @@ const walletSlice = createSlice({
     setAccountName: (state, action: PayloadAction<{ id: number, name: string }>) => {
       state.accounts[action.payload.id].name = action.payload.name;
     },
-    setTokens: (state, action: PayloadAction<{ id: number, assets: AssetEntity[] }>) => {
-      state.accounts[action.payload.id].tokens = action.payload.assets;
-    },
-    addToken: (state, action: PayloadAction<{ id: number, asset: AssetEntity }>) => {
-      state.accounts[action.payload.id].tokens.unshift(action.payload.asset);
-    },
-    removeToken: (state, action: PayloadAction<{ id: number, tokenId: string }>) => {
-      state.accounts[action.payload.id].tokens = state.accounts[action.payload.id].tokens.filter(n => n.tokenIdHex !== action.payload.tokenId);
-    },
     refreshTxs: (state) => {
       state.txUpdateTrigger++;
     },
     refreshNfts: (state) => {
       state.nftsUpdateTrigger++;
     },
+    refreshTokens: (state) => {
+      state.tokensUpdateTrigger++;
+    },
     addSession(state, action: PayloadAction<AddSessionPayload>) {
       const { accountId, sessionInfo } = action.payload;
       state.accounts[accountId].sessions[sessionInfo.details.sessionId] = sessionInfo;

package/src/state/store.ts

@@ -1,6 +1,7 @@
 import { authReducer } from "./slices/auth";
 import { dappModalReducer } from "./slices/dapp";
 import { loaderReducer } from "./slices/loader";
+import { marketReducer } from "./slices/market";
 import { notificationsReducer } from "./slices/notifications";
 import { statusReducer } from "./slices/status";
 import { walletReducer } from "./slices/wallet";
@@ -12,6 +13,7 @@ export const sharedReducers = {
   wallet: walletReducer,
   auth: authReducer,
   notifications: notificationsReducer,
+  market: marketReducer,
 };
 
 export type SharedState = {
@@ -21,4 +23,5 @@ export type SharedState = {
   wallet: ReturnType<typeof walletReducer>;
   auth: ReturnType<typeof authReducer>;
   notifications: ReturnType<typeof notificationsReducer>;
+  market: ReturnType<typeof marketReducer>;
 };

package/src/types/db.types.ts

@@ -1,5 +1,5 @@
-import type { AccountType, AssetType } from "../utils/enums";
-import type { Balance } from "./wallet.types";
+import type { AccountType } from "../utils/enums";
+import type { Balance, AssetType } from "./wallet.types";
 
 export interface AssetMovement {
   address: string;
@@ -43,6 +43,13 @@ export interface AssetTransactionEntity {
   time: number;
 }
 
+export interface AssetEntity {
+  accountId: number;
+  tokenIdHex: string;
+  type: AssetType;
+  addedTime: number;
+}
+
 export interface TokenEntity {
   token: string;
   tokenIdHex: string;
@@ -50,15 +57,20 @@ export interface TokenEntity {
   ticker: string;
   iconUrl: string;
   decimals: number;
-  parentGroup: string;
+  parent: string;
 }
 
 export interface NftEntity {
   token: string;
   tokenIdHex: string;
-  parentGroup: string;
-  source: string;
+  name: string;
+  parent: string;
   collection: string;
+  series: string;
+  author: string;
+  public: string;
+  front: string;
+  back: string;
 }
 
 export interface SessionEntity {
@@ -90,13 +102,6 @@ export interface AccountEntity {
   tokensBalance: string;
 }
 
-export interface AssetEntity {
-  accountId: number;
-  tokenIdHex: string;
-  type: AssetType;
-  addedTime: number;
-}
-
 export interface AddressDTO {
   address: string;
   space: number;

package/src/types/wallet.types.ts

@@ -1,5 +1,4 @@
 import type { DAppInfo, SessionDetails } from "wallet-comms-sdk";
-import type { AssetEntity } from "./db.types";
 import type { AccountType, KeySpace } from "../utils/enums";
 
 export interface KeyPath {
@@ -20,18 +19,12 @@ export interface Balance {
   unconfirmed: string | number;
 }
 
-export interface Price {
-  value: number;
-  change: number;
-}
-
 export interface Account {
   id: number;
   name: string;
   address: string;
   balance: Balance;
   tokensBalance: Record<string, Balance>;
-  tokens: AssetEntity[];
   sessions: Record<string, SessionInfo>
 }
 
@@ -42,21 +35,52 @@ export interface VaultInfo {
   index: number;
 }
 
-export interface NftPreview {
-  infoJson: string;
-  image: string;
-}
-
 export interface SessionInfo {
   details: SessionDetails;
   appInfo: DAppInfo;
 };
 
-export interface AssetInfo {
+export interface AssetBase {
   token: string;
   tokenIdHex: string;
+  parent: string;
+}
+
+export interface TokenAsset {
+  name: string;
+  ticker: string;
+  iconUrl: string;
   decimals: number;
-  name?: string;
-  ticker?: string;
-  iconUrl?: string;
+}
+
+export interface NFTAsset {
+  name: string;
+  series: string;
+  collection: string;
+  author: string;
+  public: string;
+  front: string;
+  back: string;
+}
+
+export type AssetType = 'token' | 'nft';
+
+export type AssetInfo = 
+  | (AssetBase & { type: 'token'; data: TokenAsset })
+  | (AssetBase & { type: 'nft'; data: NFTAsset });
+
+export interface MarketData {
+  id: string;
+  name: string;
+  symbol: string;
+  image: string;
+  price: number;
+  priceChange?: number | null;
+  priceChangePercentage?: number | null;
+  marketCap?: number | null;
+  fdv?: number | null;
+  circSupply?: number | null;
+  totalSupply?: number | null;
+  maxSupply?: number | null;
+  totalVolume?: number | null;
 }

package/src/utils/asset.ts

@@ -1,53 +1,5 @@
-import { BufferUtils, GroupToken } from "libnexa-ts";
-import type { TokenEntity } from "../types/db.types";
-import { getAddressBuffer, isTestnet } from "./common";
-
-export function getNiftyToken(): TokenEntity {
-  return {
-    name: 'NiftyArt',
-    ticker: 'NIFTY',
-    iconUrl: 'https://niftyart.cash/td/niftyicon.svg',
-    parentGroup: '',
-    token: isTestnet()
-      ? 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
-      : 'nexa:tr9v70v4s9s6jfwz32ts60zqmmkp50lqv7t0ux620d50xa7dhyqqqcg6kdm6f',
-    tokenIdHex: isTestnet()
-      ? '0e38fbf897c1d10bcce33883d40acb28fa7a37cc0733598526aecbdff4b50000'
-      : 'cacf3d958161a925c28a970d3c40deec1a3fe06796fe1b4a7b68f377cdb90000',
-    decimals: 0
-  };
-}
-
-export function fetchNiftyNFT(id: string): Promise<Uint8Array> {
-  return performGet(getNiftyEndpoint() + id, 'raw');
-}
-
-export function isNiftySubgroup(group: string): boolean {
-  try {
-    const addrBuf = getAddressBuffer(group);
-    if (!GroupToken.isSubgroup(addrBuf)) {
-        return false;
-    }
-
-    return BufferUtils.bufferToHex(addrBuf.subarray(0, 32)) === getNiftyToken().tokenIdHex;
-  } catch {
-    return false;
-  }
-}
-
-export function fetchAssetDoc(url: string): Promise<any> {
-  // it is possible that legacy token description is stored on IPFS, check for this
-  // example: ipfs://bafkvmicdm2vdjgieqvk3s5ykqlddtzd42yuy7voum4cifpknjvhv3uarwu
-  url = translateIfIpfsUrl(url);
-  return performGet(url, 'json');
-}
-
-export function fetchAssetBlob(url: string): Promise<Uint8Array> {
-  // it is possible that NRC (Token / NFT) description is stored on IPFS, check for this
-  // example: ipfs://bafkvmicdm2vdjgieqvk3s5ykqlddtzd42yuy7voum4cifpknjvhv3uarwu
-  url = translateIfIpfsUrl(url);
-  return performGet(url, 'raw');
-}
+import { isTestnet } from "./common";
+import type { AssetInfo } from "../types";
 
 export function transformTokenIconUrl(icon: string, documentUrl: string): string {
   if (icon && typeof icon === 'string') {
@@ -80,8 +32,16 @@ function translateIfIpfsUrl(url: string, gateway = "https://ipfs.nebula.markets/
   return url;
 }
 
-function getNiftyEndpoint(): string {
-  return `https://${isTestnet() ? 'testnet.' : ''}niftyart.cash/_public/`;
+export function getAssetMetadata(token: string): Promise<AssetInfo> {
+  return performGet(`${getAssetsEndpoint()}/metadata/${token}`, 'json');
+}
+
+export function getAssetFileUrl(token:string, asset: string): string {
+  return `${getAssetsEndpoint()}/assets/${token}/${asset}`;
+}
+
+function getAssetsEndpoint(): string {
+  return `https://${isTestnet() ? 'testapi' : 'api'}.otoplo.com`;
 }
 
 async function performGet(url: string, responseType?: 'json' | 'raw'): Promise<any> {

package/src/utils/common.ts

@@ -170,9 +170,3 @@ export function prettifyAmount(amount: string | number): string {
   }
   return val;
 }
-
-export function calcAmountValue(amount: string | number, price: number, prettify = false): string {
-  const value = bigDecimal.multiply(amount, price);
-  const rounded = bigDecimal.round(value, 2, bigDecimal.RoundingModes.HALF_DOWN);
-  return prettify ? prettifyAmount(rounded) : rounded;
-}

package/src/utils/enums.ts

@@ -15,8 +15,3 @@ export enum SessionRequestType {
   SignTransaction = 'signTransaction',
   SendTransaction = 'sendTransaction',
 }
-
-export enum AssetType {
-  TOKEN = 'token',
-  NFT = 'nft'
-}

package/src/utils/index.ts

@@ -2,6 +2,6 @@ export * from './asset';
 export * from './common';
 export * from './enums';
 export * from './seed';
-export * from './price';
+export * from './market';
 export * from './vault';
 export * from './keypath';

package/src/utils/market.ts

@@ -0,0 +1,97 @@
+import bigDecimal from "js-big-decimal";
+import type { MarketData } from "../types/wallet.types";
+
+interface MarketDataResponse {
+  id: string;
+  circulating_supply?: number | null;
+  current_price?: number | null;
+  fully_diluted_valuation?: number | null;
+  image?: string;
+  last_updated?: string;
+  market_cap?: number | null;
+  market_cap_change_24h?: number | null;
+  market_cap_change_percentage_24h?: number | null;
+  max_supply?: number | null;
+  name?: string;
+  price_change_24h?: number | null;
+  price_change_percentage_24h?: number | null;
+  symbol?: string;
+  total_supply?: number | null;
+  total_volume?: number | null;
+}
+
+export const CURRENCIES = [
+  { code: 'usd', symbol: '$', name: 'US Dollar' },
+  { code: 'eur', symbol: '€', name: 'Euro' },
+  { code: 'gbp', symbol: '£', name: 'British Pound' },
+  { code: 'aud', symbol: 'A$', name: 'Australian Dollar' },
+  { code: 'cad', symbol: 'C$', name: 'Canadian Dollar' },
+  { code: 'chf', symbol: 'Fr', name: 'Swiss Franc' },
+  { code: 'inr', symbol: '₹',  name: 'Indian Rupee' },
+  { code: 'cny', symbol: '¥', name: 'Chinese Yuan' },
+  { code: 'jpy', symbol: '¥', name: 'Japanese Yen' },
+] as const;
+
+export type CurrencyCode = typeof CURRENCIES[number]['code'];
+
+export type CurrencySymbol = typeof CURRENCIES[number]['symbol'];
+
+export const currencySymbols = Object.fromEntries(
+  CURRENCIES.map(c => [c.code, c.symbol])
+) as Record<CurrencyCode, CurrencySymbol>;
+
+export const currencyCodes = CURRENCIES.map(c => c.code);
+
+export const SUPPORTED_TOKENS: Record<string, string> = {
+  nexacoin: 'nexa'
+};
+
+export async function getMarketData(currency: CurrencyCode): Promise<Record<string, MarketData>> {
+  const ids = Object.keys(SUPPORTED_TOKENS).join(",");
+  const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?ids=${ids}&vs_currency=${currency}`);
+  if (!res.ok) {
+    throw new Error("Failed to fetch market data");
+  }
+
+  const payload: MarketDataResponse[] = await res.json();
+  const data: Record<string, MarketData> = {};
+  payload.forEach(entry => {
+    data[SUPPORTED_TOKENS[entry.id]] = {
+      id: entry.id,
+      name: entry.name ?? '',
+      symbol: entry.symbol ?? '',
+      image: entry.image ?? '',
+      price: entry.current_price ?? 0,
+      priceChange: entry.price_change_24h,
+      priceChangePercentage: entry.price_change_percentage_24h,
+      marketCap: entry.market_cap,
+      fdv: entry.fully_diluted_valuation,
+      circSupply: entry.circulating_supply,
+      totalSupply: entry.total_supply,
+      maxSupply: entry.max_supply,
+      totalVolume: entry.total_volume
+    }
+  });
+
+  return data;
+}
+
+export function getCurrencySymbol(currency: CurrencyCode): string {
+  return currencySymbols[currency] || currency;
+}
+
+
+export function calculateFiatValue(amount: string | number, price: number, currency?: CurrencyCode): string {
+  const value = bigDecimal.multiply(amount, price);
+  const rounded = bigDecimal.round(value, 2, bigDecimal.RoundingModes.HALF_DOWN);
+  return currency ? formatMoney(rounded, currency) : rounded;
+}
+
+export function formatMoney(value: string | number, currency: CurrencyCode, locale = 'en-US'): string {
+  return new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+    maximumFractionDigits: 2,
+    minimumFractionDigits: 2
+  }).format(Number(value));
+}

package/dist/types/utils/price.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"price.d.ts","sourceRoot":"","sources":["../../../src/utils/price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASb,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;AAEjE,eAAO,MAAM,eAAe,EAEvB,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;AAE1C,eAAO,MAAM,aAAa,mEAA8B,CAAC;AAEzD,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAUrE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAEhE;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAMxD"}