@ledgerhq/live-common 34.50.0-nightly.6 → 34.51.0-nightly.0

package/src/exchange/swap/postSwapState.ts

@@ -7,14 +7,14 @@ import { getSwapAPIBaseURL, getSwapUserIP } from ".";
 
 function createSwapIntentHashes({
   provider,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
 }: {
   provider: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
 }) {
   // for example '2025-08-01' used to add a one day unique nonce to the swap intent hash
   const currentday = new Date().toISOString().split("T")[0];
@@ -24,9 +24,9 @@ function createSwapIntentHashes({
     .update(
       JSON.stringify({
         provider,
-        fromAccountId,
-        toAccountId,
-        amount,
+        fromAccountAddress,
+        toAccountAddress,
+        fromAmount,
         currentday,
       }),
     )
@@ -36,9 +36,9 @@ function createSwapIntentHashes({
     .createHash("sha256")
     .update(
       JSON.stringify({
-        fromAccountId,
-        toAccountId,
-        amount,
+        fromAccountAddress,
+        toAccountAddress,
+        fromAmount,
         currentday,
       }),
     )
@@ -52,9 +52,9 @@ export const postSwapAccepted: PostSwapAccepted = async ({
   swapId = "",
   transactionId,
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
   ...rest
 }) => {
   if (isIntegrationTestEnv())
@@ -70,9 +70,9 @@ export const postSwapAccepted: PostSwapAccepted = async ({
 
   const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
     provider,
-    fromAccountId,
-    toAccountId,
-    amount,
+    fromAccountAddress,
+    toAccountAddress,
+    fromAmount,
   });
 
   try {
@@ -99,9 +99,9 @@ export const postSwapCancelled: PostSwapCancelled = async ({
   provider,
   swapId = "",
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
   seedIdFrom,
   seedIdTo,
   refundAddress,
@@ -120,19 +120,14 @@ export const postSwapCancelled: PostSwapCancelled = async ({
 
   const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
     provider,
-    fromAccountId,
-    toAccountId,
-    amount,
+    fromAccountAddress,
+    toAccountAddress,
+    fromAmount,
   });
 
   // Check if the refundAddress and payoutAddress match the account addresses, just to eliminate this supposition
   const payloadAddressMatchAccountAddress =
-    fromAccountId &&
-    toAccountId &&
-    refundAddress &&
-    payoutAddress &&
-    fromAccountId.includes(refundAddress) &&
-    toAccountId.includes(payoutAddress);
+    fromAccountAddress === refundAddress && toAccountAddress === payoutAddress;
 
   try {
     const ipHeader = getSwapUserIP();
@@ -151,8 +146,9 @@ export const postSwapCancelled: PostSwapCancelled = async ({
       swapIntentWithProvider,
       swapIntentWithoutProvider,
       payloadAddressMatchAccountAddress,
-      fromAccountId: shouldIncludeAddresses ? fromAccountId : undefined,
-      toAccountId: shouldIncludeAddresses ? toAccountId : undefined,
+      fromAmount,
+      fromAccountAddress: shouldIncludeAddresses ? fromAccountAddress : undefined,
+      toAccountAddress: shouldIncludeAddresses ? toAccountAddress : undefined,
       payloadRefundAddress: shouldIncludeAddresses ? refundAddress : undefined,
       payloadPayoutAddress: shouldIncludeAddresses ? payoutAddress : undefined,
       maybeSeedMatch: seedIdFrom === seedIdTo, // Only true if both accounts are from the same seed and from the same chain type

package/src/exchange/swap/setBroadcastTransaction.ts

@@ -12,9 +12,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType,
   swapType,
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
 }: {
   result: { operation: Operation | string; swapId: string };
   provider: string;
@@ -23,9 +23,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType?: DeviceModelId;
   swapType?: TradeMethod;
   swapAppVersion?: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
 }) => {
   const { operation, swapId } = result;
 
@@ -45,9 +45,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType: swapType,
       swapAppVersion,
-      fromAccountId,
-      toAccountId,
-      amount,
+      fromAccountAddress,
+      toAccountAddress,
+      fromAmount,
     });
   } else {
     postSwapAccepted({
@@ -59,9 +59,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType,
       swapAppVersion,
-      fromAccountId,
-      toAccountId,
-      amount,
+      fromAccountAddress,
+      toAccountAddress,
+      fromAmount,
     });
   }
 };

package/src/exchange/swap/types.ts

@@ -200,9 +200,9 @@ type SwapStateRequest = {
   hardwareWalletType: DeviceModelId;
   swapType: TradeMethod;
   swapAppVersion?: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
   seedIdFrom?: string;
   seedIdTo?: string;
   refundAddress?: string;

package/src/families/tezos/config.ts

@@ -22,8 +22,8 @@ export const tezosConfig: Record<string, ConfigInfo> = {
         minGasLimit: 600,
         minRevealGasLimit: 300,
         minStorageLimit: 0,
-        minFees: 500,
-        minEstimatedFees: 500,
+        minFees: 300,
+        minEstimatedFees: 300,
       },
     },
   },

package/src/modularDrawer/hooks/modules/useRightMarketTrendModule.tsx

@@ -1,7 +1,7 @@
 import React, { useMemo } from "react";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { useMarketByCurrencies } from "../../../dada-client/hooks/useMarketByCurrencies";
-import { counterValueFormatter } from "../../utils/counterValueFormatter";
+import counterValueFormatter from "../../../market/utils/countervalueFormatter";
 import { UseBalanceDeps } from "../../utils/type";
 
 const createMarketPriceItem = ({

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,16 +1,14 @@
-import { useMemo, type ReactNode } from "react";
-import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import { useMemo } from "react";
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
-import { counterValueFormatter } from "../utils/counterValueFormatter";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { UseBalanceDeps } from "../utils/type";
+import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { calculateProviderTotals } from "../utils/calculateProviderTotal";
 import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
 
 export type AssetDeps = {
   useBalanceDeps: UseBalanceDeps;
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   assetsMap: Map<
     string,
     { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
@@ -22,50 +20,36 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
     providerCurrency: CryptoOrTokenCurrency,
     totalBalance: BigNumber,
     totalFiatValue: BigNumber,
-    counterValueCurrency: Currency,
-    locale: string,
-    discreet: boolean,
   ) => {
-    const unit = providerCurrency.units?.[0];
-    const balance = unit
-      ? formatCurrencyUnit(unit, totalBalance, { showCode: true, discreet })
-      : `${totalBalance.toFixed()} ${providerCurrency.ticker ?? providerCurrency.symbol}`;
-    const fiatValue = counterValueFormatter({
-      currency: counterValueCurrency.ticker,
-      value: totalFiatValue.toNumber(),
-      locale,
-      allowZeroValue: true,
-    });
-    return { balance, fiatValue };
+    return {
+      currency: providerCurrency,
+      balance: totalBalance,
+      fiatValue: totalFiatValue.toNumber(),
+    };
   };
 
   return function useRightBalanceAsset(assets: CryptoOrTokenCurrency[]) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+    const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const grouped = useMemo(
-      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency, discreet),
-      [flattenedAccounts, state, counterValueCurrency, discreet],
+      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency),
+      [flattenedAccounts, state, counterValueCurrency],
     );
 
     return useMemo(() => {
       const balanceMap = new Map();
 
       for (const [, { currencies, mainCurrency }] of assetsMap) {
-        const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
-
-        const { balance, fiatValue } = formatProviderResult(
-          mainCurrency,
-          totalBalance,
-          totalFiatValue,
-          counterValueCurrency,
-          locale,
-          discreet,
+        const { totalBalance, totalFiatValue, referenceCurrency } = calculateProviderTotals(
+          currencies,
+          grouped,
         );
 
-        balanceMap.set(mainCurrency.id, {
-          balance: balance,
-          fiatValue: fiatValue,
-        });
+        // Use referenceCurrency from actual accounts if available, fallback to mainCurrency
+        const currencyToUse = referenceCurrency || mainCurrency;
+        const balanceData = formatProviderResult(currencyToUse, totalBalance, totalFiatValue);
+
+        balanceMap.set(mainCurrency.id, balanceData);
       }
 
       const assetsWithBalanceData = assets.map(asset => {
@@ -78,8 +62,8 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
       });
 
       return assetsWithBalanceData.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+        compareByBalanceThenFiat(a.balanceData, b.balanceData),
       );
-    }, [assets, grouped, counterValueCurrency, locale, discreet]);
+    }, [assets, grouped]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,10 +1,9 @@
-import { type ReactNode } from "react";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { UseBalanceDeps } from "../utils/type";
+import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 
 export type NetworkDeps = {
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   useBalanceDeps: UseBalanceDeps;
 };
 
@@ -14,23 +13,22 @@ type Params = {
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
   return function useRightBalanceNetwork({ networks }: Params) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+    const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const networkBalanceData = getBalanceAndFiatValueByAssets(
       flattenedAccounts,
       networks,
       state,
       counterValueCurrency,
-      discreet,
-      locale,
     );
 
     const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
 
     return networks.map(network => {
       const balanceData = balanceMap.get(network.id) || {};
+      const details = network.type === "TokenCurrency" ? network.parentCurrency : network;
       return {
-        ...network,
+        ...details,
         rightElement: balanceItem(balanceData),
         balanceData: balanceData,
       };

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -83,14 +83,19 @@ export const createNetworkConfigurationHook =
 
       const result = composedHook(assets);
 
-      if (leftElement === "numberOfAccounts" || leftElement === "numberOfAccountsAndApy") {
+      if (
+        leftElement === "numberOfAccounts" ||
+        leftElement === "numberOfAccountsAndApy" ||
+        leftElement === undefined // default
+      ) {
         result.sort((a, b) => (b?.count || 0) - (a?.count || 0));
       }
 
-      if (rightElement === "balance") {
-        const { discreet } = NetworkConfigurationDeps.useBalanceDeps();
-
-        result.sort((a, b) => compareByBalanceThenFiat(a?.balanceData, b?.balanceData, discreet));
+      if (
+        rightElement === "balance" ||
+        rightElement === undefined // default
+      ) {
+        result.sort((a, b) => compareByBalanceThenFiat(a?.balanceData, b?.balanceData));
       }
 
       return result;

package/src/modularDrawer/utils/__tests__/calculateProviderTotal.test.ts

@@ -0,0 +1,237 @@
+import { calculateProviderTotals } from "../calculateProviderTotal";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+import { genAccount } from "../../../mock/account";
+import BigNumber from "bignumber.js";
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+describe("calculateProviderTotals", () => {
+  const mockBTCCurrency = createFixtureCryptoCurrency("bitcoin");
+  const mockETHCurrency = createFixtureCryptoCurrency("ethereum");
+
+  const mockBTCAccount = genAccount("btc-account", { currency: mockBTCCurrency });
+  const mockUSDCAccount = genAccount("usdc-account", { currency: mockETHCurrency });
+  const mockBscUSDCAccount = genAccount("bsc-usdc-account", { currency: mockETHCurrency });
+
+  const mockUSDCToken: CryptoOrTokenCurrency = {
+    type: "TokenCurrency",
+    id: "ethereum/erc20/usdc",
+    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    parentCurrency: mockETHCurrency,
+    tokenType: "erc20",
+    name: "USD Coin",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
+  };
+
+  const mockBscUSDCToken: CryptoOrTokenCurrency = {
+    type: "TokenCurrency",
+    id: "bsc/bep20/usdc",
+    contractAddress: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    parentCurrency: mockETHCurrency, // Using ETH as parent for simplicity
+    tokenType: "bep20",
+    name: "USD Coin (BSC)",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 18 }],
+  };
+
+  it("should return totals with hasAccounts false when no accounts exist", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {};
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(0),
+      totalFiatValue: new BigNumber(0),
+      hasAccounts: false,
+      referenceCurrency: null,
+    });
+  });
+
+  it("should sum totals across multiple currencies", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockBTCCurrency.id]: {
+        totalBalance: new BigNumber(100000000), // 1 BTC
+        totalFiatValue: new BigNumber(50000), // $50,000
+        accounts: [mockBTCAccount], // Non-empty accounts array
+        referenceCurrency: mockBTCCurrency,
+      },
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC
+        totalFiatValue: new BigNumber(1), // $1
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // BTC (magnitude 8) sets reference, USDC (magnitude 6) gets normalized
+    // USDC: 1000000 * 10^(8-6) = 1000000 * 100 = 100000000
+    // Total: 100000000 (BTC) + 100000000 (normalized USDC) = 200000000
+    expect(result).toEqual({
+      totalBalance: new BigNumber(200000000), // Combined balance after magnitude normalization
+      totalFiatValue: new BigNumber(50001), // Combined fiat value
+      hasAccounts: true,
+      referenceCurrency: mockBTCCurrency, // First currency with accounts
+    });
+  });
+
+  it("should return referenceCurrency from first asset group with accounts", () => {
+    const currencies = [mockUSDCToken, mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken, // ETH USDC with 6 decimals
+      },
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("1000000000000000000"),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockBscUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockBscUSDCToken, // BSC USDC with 18 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result.referenceCurrency).toEqual(mockUSDCToken); // First currency
+    expect(result.hasAccounts).toBe(true);
+  });
+
+  it("should skip currencies with no accounts", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+      // BTC has no entry in groupedAccounts
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(1000000), // Only USDC balance
+      totalFiatValue: new BigNumber(1), // Only USDC fiat value
+      hasAccounts: true,
+      referenceCurrency: mockUSDCToken,
+    });
+  });
+
+  it("should skip currencies with empty accounts array", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockBTCCurrency.id]: {
+        totalBalance: new BigNumber(100000000),
+        totalFiatValue: new BigNumber(50000),
+        accounts: [], // Empty accounts array should be skipped
+        referenceCurrency: mockBTCCurrency,
+      },
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(1000000), // Only USDC (non-empty accounts)
+      totalFiatValue: new BigNumber(1),
+      hasAccounts: true,
+      referenceCurrency: mockUSDCToken,
+    });
+  });
+
+  it("should normalize balances based on magnitude differences", () => {
+    // Test the specific code: magnitude normalization between currencies
+    const currencies = [mockUSDCToken, mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC with 6 decimals
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount],
+        referenceCurrency: mockUSDCToken, // 6 decimals
+      },
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("1000000000000000000"), // 1 USDC with 18 decimals
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockBscUSDCAccount],
+        referenceCurrency: mockBscUSDCToken, // 18 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // First currency (USDC) sets reference magnitude of 6
+    // Second currency (BSC USDC) has magnitude 18, so diff = 6 - 18 = -12
+    // BSC balance of 1000000000000000000 shifted by -12 = 1000000
+    // Total should be 1000000 + 1000000 = 2000000
+    expect(result.totalBalance).toEqual(new BigNumber(2000000));
+    expect(result.totalFiatValue).toEqual(new BigNumber(2));
+    expect(result.hasAccounts).toBe(true);
+    expect(result.referenceCurrency).toEqual(mockUSDCToken);
+  });
+
+  it("should handle magnitude normalization when referenceCurrency is set", () => {
+    const currencies = [mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("2000000000000000000"),
+        totalFiatValue: new BigNumber(2),
+        accounts: [mockBscUSDCAccount],
+        referenceCurrency: mockBscUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result.totalBalance).toEqual(new BigNumber("2000000000000000000"));
+    expect(result.referenceCurrency).toEqual(mockBscUSDCToken);
+  });
+
+  it("should handle zero magnitude difference correctly", () => {
+    const sameMagnitudeCurrency: CryptoOrTokenCurrency = {
+      type: "TokenCurrency",
+      id: "ethereum/erc20/usdc2",
+      contractAddress: "0x1234567890123456789012345678901234567890",
+      parentCurrency: mockETHCurrency,
+      tokenType: "erc20",
+      name: "USD Coin 2",
+      ticker: "USDC2",
+      units: [{ name: "USD Coin 2", code: "USDC2", magnitude: 6 }],
+    };
+
+    const mockSameMagnitudeAccount = genAccount("usdc2-account", { currency: mockETHCurrency });
+
+    const currencies = [mockUSDCToken, sameMagnitudeCurrency];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount],
+        referenceCurrency: mockUSDCToken, // 6 decimals
+      },
+      [sameMagnitudeCurrency.id]: {
+        totalBalance: new BigNumber(2000000), // 2 USDC2
+        totalFiatValue: new BigNumber(2),
+        accounts: [mockSameMagnitudeAccount],
+        referenceCurrency: sameMagnitudeCurrency, // 6 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // Both have magnitude 6, so diff = 6 - 6 = 0
+    // No shifting needed, simple addition: 1000000 + 2000000 = 3000000
+    expect(result.totalBalance).toEqual(new BigNumber(3000000));
+    expect(result.totalFiatValue).toEqual(new BigNumber(3));
+  });
+});