@ledgerhq/live-common 24.0.0-next.0 → 24.0.0-next.1

package/src/exchange/index.ts

@@ -46,6 +46,13 @@ export type ExchangeProviderNameAndSignature = {
   nameAndPubkey: Buffer;
   signature: Buffer;
 };
+
+export type SwapProviderConfig = ExchangeProviderNameAndSignature & {
+  curve: string;
+  needsKYC: boolean;
+  needsBearerToken: boolean;
+};
+
 export const isExchangeSupportedByApp = (
   appName: string,
   appVersion: string

package/src/exchange/swap/checkQuote.test.ts

@@ -0,0 +1,53 @@
+import axios from "axios";
+import checkQuote from "./checkQuote";
+
+jest.mock("axios");
+const mockedAxios = jest.mocked(axios);
+
+const provider = "changelly";
+const quoteId = "RATE_ID";
+const bearerToken = "BEARER_TOKEN";
+
+describe("swap/checkQuote", () => {
+  test("should return response in case of valid rate", async () => {
+    const data = {
+      code: 1,
+      codeName: "RATE_VALID",
+      description: "KYC check passed",
+    };
+
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    const res = await checkQuote({ provider, quoteId, bearerToken });
+
+    expect(res).toEqual(data);
+  });
+
+  test("should return response in case of invalid rate", async () => {
+    const data = {
+      code: 204,
+      codeName: "MFA_REQUIRED",
+      description: "MFA Required",
+    };
+
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    const res = await checkQuote({ provider, quoteId, bearerToken });
+
+    expect(res).toEqual(data);
+  });
+});

package/src/exchange/swap/checkQuote.ts

@@ -0,0 +1,34 @@
+import { getEnv } from "../../env";
+import network from "../../network";
+import { getSwapAPIBaseURL } from "./";
+import { mockCheckQuote } from "./mock";
+import type { CheckQuote } from "./types";
+
+const checkQuote: CheckQuote = async ({ provider, quoteId, bearerToken }) => {
+  if (getEnv("MOCK") || getEnv("MOCK_SWAP_CHECK_QUOTE")) {
+    return mockCheckQuote({ provider, quoteId, bearerToken });
+  }
+
+  const request = {
+    provider,
+    rateId: quoteId,
+  };
+
+  const { data } = await network({
+    method: "POST",
+    url: `${getSwapAPIBaseURL()}/rate/check`,
+    headers: {
+      Authorization: `Bearer ${bearerToken}`,
+    },
+    data: request,
+  });
+
+  /**
+   * TODO: we might want to handle various status and error here
+   * cf. https://github.com/LedgerHQ/swap/blob/master/modules/model/src/main/scala/co/ledger/swap/model/RateStatus.scala
+   */
+
+  return data;
+};
+
+export default checkQuote;

package/src/exchange/swap/completeExchange.ts

@@ -1,22 +1,20 @@
+import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
 import { from, Observable } from "rxjs";
 import secp256k1 from "secp256k1";
-import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
-
-import { delay } from "../../promise";
-import ExchangeTransport from "../hw-app-exchange/Exchange";
-import perFamily from "../../generated/exchange";
+import { getCurrencyExchangeConfig } from "../";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import { TransactionRefusedOnDevice } from "../../errors";
+import perFamily from "../../generated/exchange";
 import { withDevice } from "../../hw/deviceAccess";
-import { getProviderNameAndSignature } from "./";
-import { getCurrencyExchangeConfig } from "../";
-
+import { delay } from "../../promise";
+import ExchangeTransport from "../hw-app-exchange/Exchange";
 import type {
   CompleteExchangeInputSwap,
   CompleteExchangeRequestEvent,
 } from "../platform/types";
+import { getProviderConfig } from "./";
 
 const withDevicePromise = (deviceId, fn) =>
   withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
@@ -45,7 +43,7 @@ const completeExchange = (
 
     const confirmExchange = async () => {
       await withDevicePromise(deviceId, async (transport) => {
-        const providerNameAndSignature = getProviderNameAndSignature(provider);
+        const providerConfig = getProviderConfig(provider);
         const exchange = new ExchangeTransport(
           transport,
           exchangeType,
@@ -75,10 +73,10 @@ const completeExchange = (
         const errorsKeys = Object.keys(errors);
         if (errorsKeys.length > 0) throw errors[errorsKeys[0]]; // throw the first error
 
-        await exchange.setPartnerKey(providerNameAndSignature.nameAndPubkey);
+        await exchange.setPartnerKey(providerConfig.nameAndPubkey);
         if (unsubscribed) return;
 
-        await exchange.checkPartner(providerNameAndSignature.signature);
+        await exchange.checkPartner(providerConfig.signature);
         if (unsubscribed) return;
 
         await exchange.processTransaction(

package/src/exchange/swap/getExchangeRates.ts

@@ -13,9 +13,9 @@ import type {
   Transaction,
   Unit,
 } from "../../types";
-import { getSwapAPIBaseURL, getSwapAPIError } from "./";
+import { getAvailableProviders, getSwapAPIBaseURL, getSwapAPIError } from "./";
 import { mockGetExchangeRates } from "./mock";
-import type { Exchange, GetExchangeRates } from "./types";
+import type { CustomMinOrMaxError, Exchange, GetExchangeRates } from "./types";
 
 const getExchangeRates: GetExchangeRates = async (
   exchange: Exchange,
@@ -40,6 +40,7 @@ const getExchangeRates: GetExchangeRates = async (
     from,
     to,
     amountFrom: apiAmount.toString(),
+    providers: usesV3 ? getAvailableProviders() : undefined,
   };
   const res = await network({
     method: "POST",
@@ -122,7 +123,7 @@ const inferError = (
     errorCode?: number;
     errorMessage?: string;
   }
-): Error | undefined => {
+): Error | CustomMinOrMaxError | undefined => {
   const tenPowMagnitude = new BigNumber(10).pow(unitFrom.magnitude);
   const { amountTo, minAmountFrom, maxAmountFrom, errorCode, errorMessage } =
     responseData;
@@ -157,6 +158,7 @@ const inferError = (
             showCode: true,
           }
         ),
+        amount: new BigNumber(amount),
       });
     }
   }

package/src/exchange/swap/getProviders.ts

@@ -1,15 +1,23 @@
-import type { GetProviders } from "./types";
-import network from "../../network";
-import { getSwapAPIBaseURL } from "./";
+import qs from "qs";
 import { getEnv } from "../../env";
-import { mockGetProviders } from "./mock";
 import { SwapNoAvailableProviders } from "../../errors";
+import network from "../../network";
+import { getAvailableProviders, getSwapAPIBaseURL } from "./";
+import { mockGetProviders } from "./mock";
+import type { GetProviders } from "./types";
 
 const getProviders: GetProviders = async () => {
   if (getEnv("MOCK")) return mockGetProviders();
+
+  // Rely on the api base to determine the version logic
+  const usesV3 = getSwapAPIBaseURL().endsWith("v3");
+
   const res = await network({
     method: "GET",
     url: `${getSwapAPIBaseURL()}/providers`,
+    params: usesV3 ? { whitelist: getAvailableProviders() } : undefined,
+    paramsSerializer: (params) =>
+      qs.stringify(params, { arrayFormat: "comma" }),
   });
 
   if (!res.data.length) {

package/src/exchange/swap/getStatus.ts

@@ -1,18 +1,9 @@
+import { getEnv } from "../../env";
 import network from "../../network";
 import { getSwapAPIBaseURL } from "./";
-import type { GetMultipleStatus, GetStatus } from "./types";
-import { getEnv } from "../../env";
 import { mockGetStatus } from "./mock";
-import { SwapUnknownSwapId } from "../../errors";
-export const getStatus: GetStatus = async (status) => {
-  const updatedStatus = await getMultipleStatus([status]);
+import type { GetMultipleStatus } from "./types";
 
-  if (updatedStatus && updatedStatus.length) {
-    return updatedStatus[0];
-  }
-
-  throw new SwapUnknownSwapId(undefined, { ...status });
-};
 export const getMultipleStatus: GetMultipleStatus = async (statusList) => {
   if (getEnv("MOCK")) return mockGetStatus(statusList);
   const res = await network({
@@ -22,4 +13,3 @@ export const getMultipleStatus: GetMultipleStatus = async (statusList) => {
   });
   return res.data;
 };
-export default getStatus;

package/src/exchange/swap/hooks/useProviderRates.test.ts

@@ -1,8 +1,12 @@
-import { renderHook, act } from "@testing-library/react-hooks";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { act, renderHook } from "@testing-library/react-hooks";
 import BigNumber from "bignumber.js";
 import { useProviderRates } from ".";
 import { getExchangeRates } from "..";
+import {
+  SwapExchangeRateAmountTooHigh,
+  SwapExchangeRateAmountTooLow,
+} from "../../../errors";
 import { genAccount } from "../../../mock/account";
 import { mockGetExchangeRates } from "../mock";
 
@@ -184,6 +188,104 @@ describe("useProviderRates", () => {
     expect(result.current.rates.value).toBeUndefined();
   });
 
+  it("should sort SwapExchangeRateAmountTooLow based on amount", async () => {
+    const swapExchangeRateAmountTooLowError1 = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(1),
+      }
+    );
+
+    const swapExchangeRateAmountTooLowError2 = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(2),
+      }
+    );
+
+    mockedRates[0].error = swapExchangeRateAmountTooLowError2;
+    mockedRates[1].error = swapExchangeRateAmountTooLowError1;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(swapExchangeRateAmountTooLowError1);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("should sort SwapExchangeRateAmountTooHigh based on amount", async () => {
+    const swapExchangeRateAmountTooHighError1 =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(1),
+      });
+
+    const swapExchangeRateAmountTooHighError2 =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(2),
+      });
+
+    mockedRates[0].error = swapExchangeRateAmountTooHighError1;
+    mockedRates[1].error = swapExchangeRateAmountTooHighError2;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(
+      swapExchangeRateAmountTooHighError2
+    );
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("SwapExchangeRateAmountTooLow should take precedence over standard errors", async () => {
+    const swapExchangeRateAmountTooLowError = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(1),
+      }
+    );
+
+    const standardError = new Error("Error");
+
+    mockedRates[0].error = standardError;
+    mockedRates[1].error = swapExchangeRateAmountTooLowError;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(swapExchangeRateAmountTooLowError);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("SwapExchangeRateAmountTooHigh should take precedence over standard errors", async () => {
+    const SwapExchangeRateAmountTooHighError =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(1),
+      });
+
+    const standardError = new Error("Error");
+
+    mockedRates[0].error = standardError;
+    mockedRates[1].error = SwapExchangeRateAmountTooHighError;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(SwapExchangeRateAmountTooHighError);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
   it("should call 'onNoRates' if there are no rates returned by the server", async () => {
     const onNoRates = jest.fn(() => {});
     mockedGetExchangeRates.mockResolvedValue([]);

package/src/exchange/swap/hooks/useProviderRates.ts

@@ -1,13 +1,12 @@
 import { useCallback, useEffect, useReducer, useState } from "react";
+import { getExchangeRates } from "..";
+import { Transaction } from "../../../generated/types";
+import type { CustomMinOrMaxError, Exchange, ExchangeRate } from "../types";
 import {
   OnNoRatesCallback,
   SetExchangeRateCallback,
   SwapSelectorStateType,
 } from "./useSwapTransaction";
-import { getExchangeRates } from "..";
-import { Exchange, ExchangeRate } from "../types";
-import { pickExchangeRate } from "../utils";
-import { Transaction } from "../../../generated/types";
 
 export type RatesReducerState = {
   status?: string | null;
@@ -34,14 +33,12 @@ const ratesReducer = (state: RatesReducerState, action): RatesReducerState => {
 export const useProviderRates = ({
   fromState,
   toState,
-  exchangeRate,
   transaction,
   onNoRates,
   setExchangeRate,
 }: {
   fromState: SwapSelectorStateType;
   toState: SwapSelectorStateType;
-  exchangeRate?: ExchangeRate | null | undefined;
   transaction?: Transaction | null | undefined;
   onNoRates?: OnNoRatesCallback | null | undefined;
   setExchangeRate?: SetExchangeRateCallback | null | undefined;
@@ -82,23 +79,74 @@ export const useProviderRates = ({
             undefined,
             toCurrency
           );
+
           if (abort) return;
           if (rates.length === 0) {
             onNoRates && onNoRates({ fromState, toState });
           }
+
           // Discard bad provider rates
-          let rateError: Error | null | undefined = null;
+          let rateError: Error | CustomMinOrMaxError | null | undefined = null;
           rates = rates.reduce<ExchangeRate[]>((acc, rate) => {
             rateError = rateError ?? rate.error;
+
+            /**
+             * If we have an error linked to the ammount, this error takes
+             * precedence over the other (like a "CurrencyNotSupportedError" one
+             * for example)
+             */
+            if (
+              rateError?.name !== rate.error?.name &&
+              (rate.error?.name === "SwapExchangeRateAmountTooLow" ||
+                rate.error?.name === "SwapExchangeRateAmountTooHigh")
+            ) {
+              rateError = rate.error;
+            }
+
+            if (
+              rateError?.name === rate.error?.name &&
+              (rate.error?.name === "SwapExchangeRateAmountTooLow" ||
+                rate.error?.name === "SwapExchangeRateAmountTooHigh")
+            ) {
+              /**
+               * Comparison pivot, depending on the order in which we want to sort errors
+               * If the order is ascending, the pivot is -1, otherwise it's 1
+               * Based on returns from https://mikemcl.github.io/bignumber.js/#cmp
+               */
+              const cmp =
+                rateError?.name === "SwapExchangeRateAmountTooLow" ? -1 : 1;
+
+              /**
+               * If the amount is too low, the user should put at least the
+               * minimum amount possible
+               * If the amount is too high, the user should put at most the
+               * maximum amount possible
+               */
+
+              rateError =
+                (rateError as CustomMinOrMaxError).amount.comparedTo(
+                  (rate.error as CustomMinOrMaxError)?.amount
+                ) === cmp
+                  ? rateError
+                  : rate.error;
+            }
+
             return rate.error ? acc : [...acc, rate];
           }, []);
+
           if (rates.length === 0 && rateError) {
             // If all the rates are in error
             dispatchRates({ type: "error", payload: rateError });
           } else {
             dispatchRates({ type: "set", payload: rates });
-            setExchangeRate &&
-              pickExchangeRate(rates, exchangeRate, setExchangeRate);
+
+            /**
+             * Select the first rate returned by the API. Should be the prefered
+             * rate for the user. Rate ordering logic is handeled on backend side
+             */
+            const rate = rates?.length > 0 ? rates[0] : null;
+
+            setExchangeRate && setExchangeRate(rate);
           }
         } catch (error) {
           !abort && dispatchRates({ type: "error", payload: error });

package/src/exchange/swap/hooks/useSwapTransaction.ts

@@ -1,24 +1,24 @@
-import { useMemo } from "react";
+import { AmountRequired } from "@ledgerhq/errors";
 import { BigNumber } from "bignumber.js";
+import { useMemo } from "react";
+import {
+  RatesReducerState,
+  useFromState,
+  useProviderRates,
+  useToState,
+} from ".";
 import useBridgeTransaction, {
   Result as UseBridgeTransactionReturnType,
 } from "../../../bridge/useBridgeTransaction";
 import type {
   Account,
+  CryptoCurrency,
   TokenAccount,
   TokenCurrency,
-  CryptoCurrency,
 } from "../../../types";
 import { ExchangeRate } from "../types";
-import { AmountRequired } from "@ledgerhq/errors";
-import { useUpdateMaxAmount } from "./useUpdateMaxAmount";
-import {
-  RatesReducerState,
-  useFromState,
-  useProviderRates,
-  useToState,
-} from ".";
 import { useReverseAccounts } from "./useReverseAccounts";
+import { useUpdateMaxAmount } from "./useUpdateMaxAmount";
 
 export type SwapSelectorStateType = {
   currency: null | undefined | TokenCurrency | CryptoCurrency;
@@ -65,6 +65,7 @@ export type OnNoRatesCallback = (arg: {
 export type SetExchangeRateCallback = (
   exchangeRate?: ExchangeRate | null
 ) => void;
+export type SetIsSendMaxLoading = (boolean) => void;
 
 export const useFromAmountError = (
   errors: Record<string, Error | undefined>
@@ -82,16 +83,16 @@ export const useFromAmountError = (
 
 export const useSwapTransaction = ({
   accounts,
-  exchangeRate,
   setExchangeRate,
+  setIsSendMaxLoading,
   defaultCurrency = selectorStateDefaultValues.currency,
   defaultAccount = selectorStateDefaultValues.account,
   defaultParentAccount = selectorStateDefaultValues.parentAccount,
   onNoRates,
 }: {
   accounts?: Account[];
-  exchangeRate?: ExchangeRate;
   setExchangeRate?: SetExchangeRateCallback;
+  setIsSendMaxLoading?: SetIsSendMaxLoading;
   defaultCurrency?: SwapSelectorStateType["currency"];
   defaultAccount?: SwapSelectorStateType["account"];
   defaultParentAccount?: SwapSelectorStateType["parentAccount"];
@@ -136,12 +137,12 @@ export const useSwapTransaction = ({
     parentAccount: fromParentAccount,
     transaction,
     feesStrategy: transaction?.feesStrategy,
+    setIsSendMaxLoading,
   });
 
   const { rates, refetchRates } = useProviderRates({
     fromState,
     toState,
-    exchangeRate,
     transaction,
     onNoRates,
     setExchangeRate,

package/src/exchange/swap/hooks/useUpdateMaxAmount.test.ts

@@ -1,10 +1,10 @@
-import { renderHook, act } from "@testing-library/react-hooks";
 import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
-import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
-import { genAccount, genTokenAccount } from "../../../mock/account";
+import { act, renderHook } from "@testing-library/react-hooks";
 import BigNumber from "bignumber.js";
-import ethBridge from "../../../families/ethereum/bridge/mock";
 import { checkAccountSupported } from "../../../account/support";
+import ethBridge from "../../../families/ethereum/bridge/mock";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
 
 // Needs to be mocked since userSupportedCurrencies is initially empty.
 jest.mock("../../../account/support");
@@ -77,6 +77,33 @@ describe("updateAmountUsingMax", () => {
     expect(setFromAmount.mock.calls[0][0]).toBe(ZERO);
   });
 
+  it("should toggle setIsSendMaxLoading", async () => {
+    const setIsSendMaxLoading = jest.fn();
+
+    const amount = new BigNumber(0.5);
+    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+    const { result } = renderHook(useUpdateMaxAmount, {
+      initialProps: { ...defaultProps, setIsSendMaxLoading },
+    });
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(true);
+    setIsSendMaxLoading.mockClear();
+
+    // Lest resort solution, since waitFor and other helpers will not work here.
+    await wait();
+
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+  });
+
   it("should update the max amount whenever the dependencies change", async () => {
     const { result, rerender } = renderHook(useUpdateMaxAmount, {
       initialProps: defaultProps,

package/src/exchange/swap/hooks/useUpdateMaxAmount.ts

@@ -1,13 +1,13 @@
+import BigNumber from "bignumber.js";
 import { useCallback, useEffect, useState } from "react";
 import { getAccountBridge } from "../../../bridge";
-
+import { Transaction } from "../../../generated/types";
 import {
-  SwapTransactionType,
+  SetIsSendMaxLoading,
   SwapDataType,
   SwapSelectorStateType,
+  SwapTransactionType,
 } from "./useSwapTransaction";
-import { Transaction } from "../../../generated/types";
-import BigNumber from "bignumber.js";
 
 export const ZERO = new BigNumber(0);
 
@@ -17,27 +17,31 @@ export const useUpdateMaxAmount = ({
   parentAccount,
   transaction,
   feesStrategy,
+  setIsSendMaxLoading,
 }: {
   setFromAmount: SwapTransactionType["setFromAmount"];
   account: SwapSelectorStateType["account"];
   parentAccount: SwapSelectorStateType["parentAccount"];
   transaction: SwapTransactionType["transaction"];
   feesStrategy: Transaction["feesStrategy"];
+  setIsSendMaxLoading?: SetIsSendMaxLoading;
 }): {
   isMaxEnabled: SwapDataType["isMaxEnabled"];
   toggleMax: SwapTransactionType["toggleMax"];
 } => {
-  const [isMaxEnabled, setMax] = useState<SwapDataType["isMaxEnabled"]>(false);
+  const [isMaxEnabled, setIsMaxEnabled] =
+    useState<SwapDataType["isMaxEnabled"]>(false);
 
   const toggleMax: SwapTransactionType["toggleMax"] = useCallback(
     () =>
-      setMax((previous) => {
+      setIsMaxEnabled((previous) => {
         if (previous) {
           setFromAmount(ZERO);
+          setIsSendMaxLoading?.(false);
         }
         return !previous;
       }),
-    [setFromAmount]
+    [setFromAmount, setIsSendMaxLoading]
   );
 
   /* UPDATE from amount to the estimate max spendable on account
@@ -47,11 +51,13 @@ export const useUpdateMaxAmount = ({
       const updateAmountUsingMax = async () => {
         if (!account) return;
         const bridge = getAccountBridge(account, parentAccount);
+        setIsSendMaxLoading?.(true);
         const amount = await bridge.estimateMaxSpendable({
           account,
           parentAccount,
           transaction,
         });
+        setIsSendMaxLoading?.(false);
         setFromAmount(amount);
       };