@imtbl/sdk 1.78.1 → 1.78.2

package/dist/browser/checkout/SwapWidget-CO4Ks4Im.js

@@ -0,0 +1,1850 @@
+import { u as useTranslation, cX as WidgetTheme, a6 as getRemoteImage, q as jsxs, cY as quickswapFooterStyles, D as Box, cZ as quickswapFooterLogoStyles, p as jsx, at as Body, c_ as quickswapFooterDisclaimerTextStyles, r as reactExports, J as Button, c$ as getImxTokenImage, F as Drawer, bm as CloudImage, H as Heading, cf as Logo, aD as Icon, bp as BigNumber, bN as formatUnits, bu as calculateCryptoToFiat, bJ as tokenValueFormat, bU as isGasFree, cv as parseUnits, cs as formatZeroAmount, bW as ConnectLoaderContext, ai as getDefaultTokenImage, ak as isNativeToken, ct as NATIVE, bV as CryptoFiatContext, a9 as ViewContext, M as useAnalytics, c0 as CryptoFiatActions, cy as DEFAULT_QUOTE_REFRESH_INTERVAL, _ as isPassportProvider, d0 as parseEther, bj as amountInputValidation, av as Tooltip, T as UserJourney, bh as Environment, V as ViewActions, n as SharedViews, i as getL2ChainId, Q as Fragment, d1 as ESTIMATE_DEBOUNCE, d2 as DEFAULT_TOKEN_VALIDATION_DECIMALS, aN as isAddressSanctioned, cx as DEFAULT_TOKEN_DECIMALS, ac as EventTargetContext, d3 as sendSwapWidgetCloseEvent, aV as orchestrationEvents, I as IMTBLWidgetEvents, bD as HeaderNavigation, L as LoadingView, aT as SimpleLayout, cB as IMX_TOKEN_SYMBOL, c5 as CheckoutErrorType, cG as SimpleTextBody, cH as FooterButton, cE as heroBackGroundStyles, cF as heroImageStyles, b4 as Trans, b3 as Link, bG as FooterLogo, aa as useHandover, bc as viewReducer, bd as initialViewState, aj as TokenFilterTypes, d4 as DEFAULT_BALANCE_RETRY_POLICY, aM as fetchRiskAssessment, d5 as SwapDirection$1, cq as WalletProviderName, cN as StatusView, d6 as sendSwapSuccessEvent, bH as StatusType, d7 as sendSwapFailedEvent, d8 as sendSwapRejectedEvent, E as ErrorView, bn as ServiceUnavailableErrorView, c3 as CryptoFiatProvider } from './index-BDZfw_Cp.js';
+import { S as SelectForm, T as TextInputForm, F as Fees, a as TransactionRejected, N as NetworkSwitchDrawer, W as WalletApproveHero, g as getAllowedBalances } from './WalletApproveHero-Bj4aKxP9.js';
+import { u as useInterval } from './useInterval-WSD1wTJp.js';
+import { S as SwapWidgetViews, T as TopUpView } from './TopUpView-CHsQmxQQ.js';
+import { S as SpendingCapHero } from './SpendingCapHero-Dp3KVsiY.js';
+import './TokenImage-BNq0SnBY.js';
+import './FeesBreakdown-Cnmi6JuS.js';
+
+function QuickswapFooter({ theme, environment }) {
+    const { t } = useTranslation();
+    const logo = theme === WidgetTheme.DARK
+        ? getRemoteImage(environment, '/quickswapdark.webp')
+        : getRemoteImage(environment, '/quickswaplight.webp');
+    return (jsxs(Box, { testId: "quickswap-footer-container", sx: quickswapFooterStyles, children: [jsxs(Box, { testId: "quickswap-logo", sx: quickswapFooterLogoStyles, children: [jsx(Body, { size: "xSmall", sx: { paddingRight: 'base.spacing.x1' }, children: "By" }), jsx("img", { style: { height: '26px' }, alt: "Quickswap logo", src: logo })] }), jsx(Body, { testId: "quickswap-footer-disclaimer-text", size: "xSmall", sx: quickswapFooterDisclaimerTextStyles, children: t('footers.quickswapFooter.disclaimerText') })] }));
+}
+
+const initialSwapState = {
+    exchange: null,
+    walletProviderName: null,
+    network: null,
+    tokenBalances: [],
+    supportedTopUps: null,
+    allowedTokens: [],
+    autoProceed: false,
+    riskAssessment: undefined,
+};
+var SwapActions;
+(function (SwapActions) {
+    SwapActions["SET_EXCHANGE"] = "SET_EXCHANGE";
+    SwapActions["SET_WALLET_PROVIDER_NAME"] = "SET_WALLET_PROVIDER_NAME";
+    SwapActions["SET_NETWORK"] = "SET_NETWORK";
+    SwapActions["SET_SUPPORTED_TOP_UPS"] = "SET_SUPPORTED_TOP_UPS";
+    SwapActions["SET_TOKEN_BALANCES"] = "SET_TOKEN_BALANCES";
+    SwapActions["SET_ALLOWED_TOKENS"] = "SET_ALLOWED_TOKENS";
+    SwapActions["SET_AUTO_PROCEED"] = "SET_AUTO_PROCEED";
+    SwapActions["SET_RISK_ASSESSMENT"] = "SET_RISK_ASSESSMENT";
+})(SwapActions || (SwapActions = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SwapContext = reactExports.createContext({
+    swapState: initialSwapState,
+    swapDispatch: () => { },
+});
+SwapContext.displayName = 'SwapContext'; // help with debugging Context in browser
+const swapReducer = (state, action) => {
+    switch (action.payload.type) {
+        case SwapActions.SET_EXCHANGE:
+            return {
+                ...state,
+                exchange: action.payload.exchange,
+            };
+        case SwapActions.SET_WALLET_PROVIDER_NAME:
+            return {
+                ...state,
+                walletProviderName: action.payload.walletProviderName,
+            };
+        case SwapActions.SET_NETWORK:
+            return {
+                ...state,
+                network: action.payload.network,
+            };
+        case SwapActions.SET_SUPPORTED_TOP_UPS:
+            return {
+                ...state,
+                supportedTopUps: {
+                    isSwapEnabled: action.payload.supportedTopUps.isSwapEnabled ?? true,
+                    isOnRampEnabled: action.payload.supportedTopUps.isOnRampEnabled ?? true,
+                    isBridgeEnabled: action.payload.supportedTopUps.isBridgeEnabled ?? true,
+                },
+            };
+        case SwapActions.SET_TOKEN_BALANCES:
+            return {
+                ...state,
+                tokenBalances: action.payload.tokenBalances,
+            };
+        case SwapActions.SET_ALLOWED_TOKENS:
+            return {
+                ...state,
+                allowedTokens: action.payload.allowedTokens,
+            };
+        case SwapActions.SET_AUTO_PROCEED:
+            return {
+                ...state,
+                autoProceed: action.payload.autoProceed,
+                direction: action.payload.direction,
+            };
+        case SwapActions.SET_RISK_ASSESSMENT:
+            return {
+                ...state,
+                riskAssessment: action.payload.riskAssessment,
+            };
+        default:
+            return state;
+    }
+};
+
+const selectInputBoxStyle = {
+    display: 'flex',
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    columnGap: 'base.spacing.x1',
+};
+const selectStyle = {
+    flex: 1,
+};
+const inputStyle = {
+    flex: 2,
+};
+
+function SelectInput({ testId, options, textInputValue, textInputPlaceholder, textInputValidator, textInputType, onTextInputChange, onTextInputBlur, onTextInputFocus, textInputTextAlign, textInputSubtext, textInputErrorMessage, testInputMode, selectTextAlign, selectSubtext, selectErrorMessage, textInputMaxButtonClick, onSelectChange, textInputDisabled, selectInputDisabled, selectedOption, coinSelectorHeading, defaultTokenImage, environment, theme, }) {
+    return (jsxs(Box, { sx: selectInputBoxStyle, children: [jsx(Box, { sx: selectStyle, children: jsx(SelectForm, { testId: `${testId}-select-form`, options: options, subtext: selectSubtext, textAlign: selectTextAlign, errorMessage: selectErrorMessage, onSelectChange: onSelectChange, disabled: selectInputDisabled, selectedOption: selectedOption, coinSelectorHeading: coinSelectorHeading, defaultTokenImage: defaultTokenImage, environment: environment, theme: theme }) }), jsx(Box, { sx: inputStyle, children: jsx(TextInputForm, { type: textInputType, testId: `${testId}-text-form`, value: textInputValue, placeholder: textInputPlaceholder, subtext: textInputSubtext, textAlign: textInputTextAlign, errorMessage: textInputErrorMessage, validator: textInputValidator, onTextInputChange: onTextInputChange, onTextInputBlur: onTextInputBlur, onTextInputFocus: onTextInputFocus, maxButtonClick: textInputMaxButtonClick, disabled: textInputDisabled, inputMode: testInputMode }) })] }));
+}
+
+function validateFromToken(fromToken) {
+    if (!fromToken)
+        return 'views.SWAP.validation.noFromTokenSelected';
+    return '';
+}
+function validateFromAmount(amount, balance) {
+    if (!amount || parseFloat(amount) === 0)
+        return 'views.SWAP.validation.noAmountInputted';
+    if (balance && Number(amount) > Number(balance))
+        return 'views.SWAP.validation.insufficientBalance';
+    return '';
+}
+function validateToToken(toToken) {
+    if (!toToken)
+        return 'views.SWAP.validation.noToTokenSelected';
+    return '';
+}
+function validateToAmount(amount) {
+    if (!amount || parseFloat(amount) === 0)
+        return 'views.SWAP.validation.noAmountInputted';
+    return '';
+}
+
+const swapButtonBoxStyle = {
+    display: 'flex',
+    flexDirection: 'column',
+    paddingY: 'base.spacing.x6',
+    paddingX: 'base.spacing.x4',
+};
+const swapButtonIconLoadingStyle = {
+    width: 'base.icon.size.400',
+};
+
+function SwapButton({ loading, validator, sendTransaction, }) {
+    const { t } = useTranslation();
+    const handleClick = async () => {
+        const canSwap = validator();
+        if (canSwap) {
+            await sendTransaction();
+        }
+    };
+    return (jsx(Box, { sx: swapButtonBoxStyle, children: jsx(Button, { testId: "swap-button", disabled: loading, variant: "primary", onClick: handleClick, size: "large", children: loading ? (jsx(Button.Icon, { icon: "Loading", sx: swapButtonIconLoadingStyle })) : t('views.SWAP.swapForm.buttonText') }) }));
+}
+
+const containerStyles$1 = {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    paddingTop: 'base.spacing.x6',
+    paddingBottom: 'base.spacing.x1',
+    height: '100%',
+};
+const contentTextStyles$1 = {
+    color: 'base.color.text.body.secondary',
+    fontFamily: 'base.font.family.heading.secondary',
+    textAlign: 'center',
+    marginTop: 'base.spacing.x4',
+};
+const actionButtonContainerStyles$1 = {
+    display: 'flex',
+    flexDirection: 'column',
+    justifyContent: 'center',
+    gap: 'base.spacing.x2',
+    height: '100%',
+    width: '100%',
+};
+const actionButtonStyles$1 = {
+    width: '100%',
+    height: 'base.spacing.x16',
+};
+const logoContainerStyles$1 = {
+    display: 'flex',
+    flexDirection: 'column',
+    justifyContent: 'center',
+    alignItems: 'center',
+    paddingTop: 'base.spacing.x6',
+};
+
+function NotEnoughImx({ environment, visible, showAdjustAmount, hasZeroImx, onCloseDrawer, onAddCoinsClick, }) {
+    const { t } = useTranslation();
+    const imxLogo = getImxTokenImage(environment);
+    return (jsx(Drawer, { size: "full", onCloseDrawer: onCloseDrawer, visible: visible, showHeaderBar: false, children: jsx(Drawer.Content, { children: jsxs(Box, { testId: "not-enough-gas-bottom-sheet", sx: containerStyles$1, children: [jsx(CloudImage, { sx: { w: 'base.icon.size.600', h: 'base.icon.size.600' }, use: (jsx("img", { src: imxLogo, alt: t(`drawers.notEnoughImx.content.${hasZeroImx ? 'noImx' : 'insufficientImx'}.heading`) })) }), jsx(Heading, { size: "small", sx: contentTextStyles$1, testId: "not-enough-gas-heading", children: t(`drawers.notEnoughImx.content.${hasZeroImx ? 'noImx' : 'insufficientImx'}.heading`) }), jsx(Body, { sx: contentTextStyles$1, children: t(`drawers.notEnoughImx.content.${hasZeroImx ? 'noImx' : 'insufficientImx'}.body`) }), jsxs(Box, { sx: actionButtonContainerStyles$1, children: [showAdjustAmount && (jsx(Button, { testId: "not-enough-gas-adjust-amount-button", sx: actionButtonStyles$1, variant: "tertiary", onClick: onCloseDrawer, children: t('drawers.notEnoughImx.buttons.adjustAmount') })), jsx(Button, { testId: "not-enough-gas-add-imx-button", sx: actionButtonStyles$1, variant: "tertiary", onClick: onAddCoinsClick, children: t('drawers.notEnoughImx.buttons.addMoreImx') }), jsx(Button, { sx: actionButtonStyles$1, variant: "tertiary", onClick: onCloseDrawer, testId: "not-enough-gas-cancel-button", children: t('drawers.notEnoughImx.buttons.cancel') })] }), jsx(Box, { sx: logoContainerStyles$1, children: jsx(Logo, { testId: "footer-logo-image", logo: "ImmutableHorizontalLockup", sx: { width: 'base.spacing.x25' } }) })] }) }) }));
+}
+
+const containerStyles = {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    paddingTop: 'base.spacing.x6',
+    paddingBottom: 'base.spacing.x4',
+    paddingX: 'base.spacing.x4',
+    height: '100%',
+};
+const contentTextStyles = {
+    color: 'base.color.text.body.secondary',
+    fontFamily: 'base.font.family.heading.secondary',
+    textAlign: 'center',
+    marginTop: 'base.spacing.x4',
+};
+const actionButtonContainerStyles = {
+    display: 'flex',
+    flexDirection: 'column',
+    justifyContent: 'flex-end',
+    alignItems: 'center',
+    gap: 'base.spacing.x2',
+    height: '100%',
+    width: '100%',
+};
+const actionButtonStyles = {
+    width: '100%',
+    height: 'base.spacing.x16',
+    marginBottom: 'base.spacing.x16',
+};
+const logoContainerStyles = {
+    display: 'flex',
+    flexDirection: 'column',
+    justifyContent: 'center',
+    alignItems: 'center',
+    paddingTop: 'base.spacing.x6',
+};
+const statusStyles = {
+    width: 'base.icon.size.600',
+    fill: 'base.color.status.fatal.bright',
+};
+
+function UnableToSwap({ visible, onCloseDrawer }) {
+    const { t } = useTranslation();
+    return (jsx(Drawer, { size: "full", onCloseDrawer: onCloseDrawer, visible: visible, showHeaderBar: false, children: jsx(Drawer.Content, { children: jsxs(Box, { testId: "unable-to-swap-bottom-sheet", sx: containerStyles, children: [jsx(Icon, { icon: "Alert", testId: "unable-to-swap-icon", variant: "bold", sx: statusStyles }), jsx(Heading, { size: "small", sx: contentTextStyles, testId: "unable-to-swap-heading", children: t('drawers.unableToSwap.heading') }), jsx(Body, { sx: contentTextStyles, children: t('drawers.unableToSwap.body') }), jsx(Box, { sx: actionButtonContainerStyles, children: jsx(Button, { sx: actionButtonStyles, variant: "tertiary", onClick: onCloseDrawer, testId: "unable-to-swap-cancel-button", children: t('drawers.unableToSwap.buttons.cancel') }) }), jsx(Box, { sx: logoContainerStyles, children: jsx(Logo, { testId: "footer-logo-image", logo: "ImmutableHorizontalLockup", sx: { width: 'base.spacing.x25' } }) })] }) }) }));
+}
+
+const useDebounce = (value, delay = 500) => {
+    const [debouncedValue, setDebouncedValue] = reactExports.useState(value);
+    reactExports.useEffect(() => {
+        const timer = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delay);
+        // Cleanup the timer used by debounce
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [value, delay]);
+    return debouncedValue;
+};
+
+/**
+ * CancellablePromise extends a promise by adding the ability to flag it as cancelled.
+ */
+class CancellablePromise {
+    static id = 0;
+    promiseId = 0;
+    promise;
+    isCancelled = false;
+    onCancel = null;
+    rejectPromise = () => { };
+    constructor(executor) {
+        CancellablePromise.id += 1;
+        this.promiseId = CancellablePromise.id;
+        this.promise = new Promise((resolve, reject) => {
+            // Save the reject function to use it for cancellation
+            this.rejectPromise = reject;
+            executor((value) => {
+                if (!this.isCancelled) {
+                    resolve(value);
+                }
+                else {
+                    reject({ cancelled: true });
+                }
+            }, (reason) => {
+                if (!this.isCancelled) {
+                    reject(reason);
+                }
+                else {
+                    reject({ cancelled: true });
+                }
+            });
+        });
+    }
+    static all(values) {
+        return new CancellablePromise((resolve, reject) => {
+            Promise.all(values.map((value) => {
+                if (value instanceof CancellablePromise) {
+                    return value.promise;
+                }
+                return value;
+            })).then(resolve, reject);
+        });
+    }
+    then(onfulfilled, onrejected) {
+        return new CancellablePromise((resolve, reject) => {
+            this.promise.then((value) => (onfulfilled ? resolve(onfulfilled(value)) : resolve(value)), (reason) => (onrejected ? resolve(onrejected(reason)) : reject(reason)));
+        });
+    }
+    catch(onrejected) {
+        return this.then(undefined, onrejected);
+    }
+    finally(onfinally) {
+        return new CancellablePromise((resolve, reject) => {
+            this.promise
+                .then(resolve, reject)
+                .finally(() => {
+                if (onfinally) {
+                    onfinally();
+                }
+            });
+        });
+    }
+    cancel() {
+        if (!this.isCancelled) {
+            this.isCancelled = true;
+            if (this.onCancel) {
+                this.onCancel();
+            }
+            this.rejectPromise({ cancelled: true });
+        }
+    }
+    onCancelled(callback) {
+        this.onCancel = callback;
+    }
+    get cancelled() {
+        return this.isCancelled;
+    }
+}
+
+/**
+ * Formats a quote into a list of fees for the fee drawer
+ * @param swapQuote
+ * @param cryptoFiatState
+ * @param t
+ */
+const formatSwapFees = (swapQuote, cryptoFiatState, t) => {
+    const fees = [];
+    if (!swapQuote.swap)
+        return fees;
+    const addFee = (estimate, label, prefix = '≈ ') => {
+        const value = BigNumber.from(estimate?.value ?? 0);
+        if (estimate && value.gt(0)) {
+            const formattedFee = formatUnits(value, estimate.token.decimals);
+            fees.push({
+                label,
+                fiatAmount: `≈ ${t('drawers.feesBreakdown.fees.fiatPricePrefix')}${calculateCryptoToFiat(formattedFee, estimate.token.symbol || '', cryptoFiatState.conversions)}`,
+                amount: `${tokenValueFormat(formattedFee)}`,
+                prefix,
+                token: estimate.token,
+            });
+        }
+    };
+    // Format gas fee
+    if (swapQuote.swap && swapQuote.swap.gasFeeEstimate) {
+        addFee(swapQuote.swap.gasFeeEstimate, t('drawers.feesBreakdown.fees.swapGasFee.label'));
+    }
+    // Format gas fee approval
+    if (swapQuote.approval && swapQuote.approval.gasFeeEstimate) {
+        addFee(swapQuote.approval.gasFeeEstimate, t('drawers.feesBreakdown.fees.approvalFee.label'));
+    }
+    // Format the secondary fees
+    swapQuote.quote?.fees?.forEach((fee) => {
+        addFee(fee.amount, t('drawers.feesBreakdown.fees.swapSecondaryFee.label', { amount: `${(fee.basisPoints / 100)}%` }), '');
+    });
+    return fees;
+};
+
+/**
+ * Adjusts the quote for gas free txn so we don't have to adjust it everywhere
+ * @param checkProvider
+ * @param currentQuote
+ */
+const processGasFree = (checkProvider, currentQuote) => {
+    if (!isGasFree(checkProvider)) {
+        return currentQuote;
+    }
+    // Remove the quote gas fees as they are being covered by Relayer
+    const adjustedQuote = { ...currentQuote };
+    if (adjustedQuote.swap?.gasFeeEstimate) {
+        adjustedQuote.swap.gasFeeEstimate.value = BigNumber.from(0);
+    }
+    if (adjustedQuote.approval?.gasFeeEstimate) {
+        adjustedQuote.approval.gasFeeEstimate.value = BigNumber.from(0);
+    }
+    return adjustedQuote;
+};
+
+/**
+ * Ensures that the fees token has the correct symbol. At the moment the dex quote doesn't return it.
+ * Assumes the fee token is the from token. If it's not, it will be incorrect.
+ * TODO: Fix this when the canonical tokens list comes into play so we can look up the symbol based on address
+ * @param fromToken Assumption is fees are delineated in this from token
+ * @param currentQuote
+ */
+const processSecondaryFees = (fromToken, currentQuote) => {
+    if (!currentQuote.quote.fees)
+        return currentQuote;
+    const adjustedFees = currentQuote.quote.fees.map((fee) => {
+        if (fee.amount.token.symbol)
+            return fee;
+        return {
+            ...fee,
+            amount: {
+                ...fee.amount,
+                token: {
+                    ...fee.amount.token,
+                    symbol: (fromToken.address === fee.amount.token.address) ? fromToken.symbol : fee.amount.token.symbol,
+                },
+            },
+        };
+    });
+    return { ...currentQuote, quote: { ...currentQuote.quote, fees: adjustedFees } };
+};
+
+/**
+ * Ensures that the quote token has the correct symbol. At the moment the dex quote doesn't return it.
+ * @param toToken
+ * @param currentQuote
+ */
+const processQuoteToken = (toToken, currentQuote) => {
+    if (!currentQuote.quote.amount && !currentQuote.quote.amountWithMaxSlippage)
+        return currentQuote;
+    const adjustedAmount = {
+        ...currentQuote.quote.amount,
+        token: {
+            ...currentQuote.quote.amount.token,
+            symbol: (toToken.address === currentQuote.quote.amount.token.address)
+                ? toToken.symbol : currentQuote.quote.amount.token.symbol,
+        },
+    };
+    const adjustedAmountWithMaxSlippage = {
+        ...currentQuote.quote.amountWithMaxSlippage,
+        token: {
+            ...currentQuote.quote.amountWithMaxSlippage.token,
+            symbol: (toToken.address === currentQuote.quote.amountWithMaxSlippage.token.address)
+                ? toToken.symbol : currentQuote.quote.amountWithMaxSlippage.token.symbol,
+        },
+    };
+    return {
+        ...currentQuote,
+        quote: {
+            ...currentQuote.quote,
+            amount: adjustedAmount,
+            amountWithMaxSlippage: adjustedAmountWithMaxSlippage,
+        },
+    };
+};
+
+const formatQuoteConversionRate = (amount, token, quote, labelKey, t) => {
+    // Grab the token from the quote secondary fees
+    // NOTE: This has a dependency on the secondary fee and needs to change if we change that fee
+    const secondaryFee = quote.quote.fees[0];
+    const fromToken = token;
+    const toToken = quote.quote.amount.token;
+    // Parse the fromAmount input, multiply by 10^decimals to convert to integer units
+    const parsedFromAmount = parseFloat(amount);
+    const relativeFromAmount = parseUnits(parsedFromAmount.toString(), fromToken.decimals);
+    const relativeToAmount = BigNumber.from(quote.quote.amount.value);
+    // Determine the maximum decimal places to equalize to
+    const fromDecimals = fromToken.decimals;
+    const toDecimals = quote.quote.amount.token.decimals;
+    const maxDecimals = Math.max(fromDecimals, toDecimals);
+    // Calculate scale factors based on maximum decimals
+    const fromScaleFactor = BigNumber.from('10').pow(maxDecimals - fromDecimals);
+    const toScaleFactor = BigNumber.from('10').pow(maxDecimals - toDecimals);
+    // Adjust amounts to the same decimal scale
+    const adjustedFromAmount = relativeFromAmount.mul(fromScaleFactor);
+    const adjustedToAmount = relativeToAmount.mul(toScaleFactor);
+    // Calculate conversion rate
+    const initialRate = adjustedToAmount.div(adjustedFromAmount);
+    // Calculate the remainder and adjust it correctly
+    const conversionRemainder = adjustedToAmount.mod(adjustedFromAmount);
+    const remainderAdjustmentFactor = BigNumber.from('10').pow(maxDecimals);
+    const adjustedRemainder = conversionRemainder.mul(remainderAdjustmentFactor).div(adjustedFromAmount);
+    // Compose the total conversion rate by adding the adjusted remainder
+    const accurateRate = initialRate.mul(remainderAdjustmentFactor).add(adjustedRemainder);
+    const formattedConversion = formatZeroAmount(tokenValueFormat(formatUnits(accurateRate, maxDecimals)), true);
+    return t(labelKey, {
+        fromSymbol: fromToken.symbol,
+        toSymbol: toToken.symbol,
+        rate: formattedConversion,
+        fee: (secondaryFee?.basisPoints ?? 0) / 100,
+    });
+};
+
+var SwapDirection;
+(function (SwapDirection) {
+    SwapDirection["FROM"] = "FROM";
+    SwapDirection["TO"] = "TO";
+})(SwapDirection || (SwapDirection = {}));
+// Ensures that the to token address does not match the from token address
+const shouldSetToAddress = (toAddress, fromAddress) => {
+    if (toAddress === undefined)
+        return false;
+    if (toAddress === '')
+        return false;
+    if (fromAddress === toAddress)
+        return false;
+    return true;
+};
+let quoteRequest;
+function SwapForm({ data, theme, cancelAutoProceed }) {
+    const { t } = useTranslation();
+    const { swapState: { allowedTokens, tokenBalances, network, autoProceed, riskAssessment, }, } = reactExports.useContext(SwapContext);
+    const { connectLoaderState } = reactExports.useContext(ConnectLoaderContext);
+    const { checkout, provider } = connectLoaderState;
+    const defaultTokenImage = getDefaultTokenImage(checkout?.config.environment, theme);
+    const formatTokenOptionsId = reactExports.useCallback((symbol, address) => (isNativeToken(address)
+        ? NATIVE
+        : `${symbol.toLowerCase()}-${address.toLowerCase()}`), []);
+    const { cryptoFiatState, cryptoFiatDispatch } = reactExports.useContext(CryptoFiatContext);
+    const { viewDispatch } = reactExports.useContext(ViewContext);
+    const [direction, setDirection] = reactExports.useState(SwapDirection.FROM);
+    const [loading, setLoading] = reactExports.useState(false);
+    const { track } = useAnalytics();
+    // Form State
+    const [fromAmount, setFromAmount] = reactExports.useState(data?.fromAmount || '');
+    const [fromAmountError, setFromAmountError] = reactExports.useState('');
+    const debouncedFromAmount = useDebounce(fromAmount, ESTIMATE_DEBOUNCE);
+    const [fromToken, setFromToken] = reactExports.useState();
+    const [fromBalance, setFromBalance] = reactExports.useState('');
+    const [fromTokenError, setFromTokenError] = reactExports.useState('');
+    const [fromMaxTrigger, setFromMaxTrigger] = reactExports.useState(0);
+    const [toAmount, setToAmount] = reactExports.useState(data?.toAmount || '');
+    const [toAmountError, setToAmountError] = reactExports.useState('');
+    const debouncedToAmount = useDebounce(toAmount, ESTIMATE_DEBOUNCE);
+    const [toToken, setToToken] = reactExports.useState();
+    const [toTokenError, setToTokenError] = reactExports.useState('');
+    const [fromFiatValue, setFromFiatValue] = reactExports.useState('');
+    const [loadedToAndFromTokens, setLoadedToAndFromTokens] = reactExports.useState(false);
+    // Quote
+    const [quote, setQuote] = reactExports.useState(null);
+    const [gasFeeValue, setGasFeeValue] = reactExports.useState('');
+    const [gasFeeToken, setGasFeeToken] = reactExports.useState(undefined);
+    const [gasFeeFiatValue, setGasFeeFiatValue] = reactExports.useState('');
+    const [tokensOptionsFrom, setTokensOptionsForm] = reactExports.useState([]);
+    const formattedFees = reactExports.useMemo(() => (quote ? formatSwapFees(quote, cryptoFiatState, t) : []), [quote, cryptoFiatState, t]);
+    const [conversionToken, setConversionToken] = reactExports.useState(null);
+    const [conversionAmount, setConversionAmount] = reactExports.useState('');
+    const swapConversionRateTooltip = reactExports.useMemo(() => {
+        if (!quote || !conversionAmount || !conversionToken)
+            return '';
+        return formatQuoteConversionRate(conversionAmount, conversionToken, quote, 'views.SWAP.swapForm.conversionRate', t);
+    }, [conversionAmount, conversionToken, quote, t]);
+    // Drawers
+    const [showNotEnoughImxDrawer, setShowNotEnoughImxDrawer] = reactExports.useState(false);
+    const [showUnableToSwapDrawer, setShowUnableToSwapDrawer] = reactExports.useState(false);
+    const [showNetworkSwitchDrawer, setShowNetworkSwitchDrawer] = reactExports.useState(false);
+    const [showTxnRejectedState, setShowTxnRejectedState] = reactExports.useState(false);
+    reactExports.useEffect(() => {
+        if (tokenBalances.length === 0)
+            return;
+        if (!network)
+            return;
+        const fromOptions = tokenBalances
+            .filter((b) => b.balance.gt(0))
+            .map((tokenBalance) => ({
+            id: formatTokenOptionsId(tokenBalance.token.symbol, tokenBalance.token.address),
+            name: tokenBalance.token.name,
+            symbol: tokenBalance.token.symbol,
+            icon: tokenBalance.token.icon,
+            balance: {
+                formattedAmount: tokenValueFormat(tokenBalance.formattedBalance),
+                formattedFiatAmount: cryptoFiatState.conversions.size === 0 ? formatZeroAmount('') : calculateCryptoToFiat(tokenBalance.formattedBalance, tokenBalance.token.symbol || '', cryptoFiatState.conversions),
+            },
+        }));
+        setTokensOptionsForm(fromOptions);
+        // Set initial token options if provided
+        if (data?.fromTokenAddress && !fromToken) {
+            setFromToken(allowedTokens.find((token) => (isNativeToken(token.address)
+                && data?.fromTokenAddress?.toLowerCase() === NATIVE)
+                || token.address?.toLowerCase()
+                    === data?.fromTokenAddress?.toLowerCase()));
+            setFromBalance(tokenBalances.find((tokenBalance) => (isNativeToken(tokenBalance.token.address)
+                && data?.fromTokenAddress?.toLowerCase() === NATIVE)
+                || (tokenBalance.token.address?.toLowerCase() === data?.fromTokenAddress?.toLowerCase()))?.formattedBalance ?? '');
+        }
+        if (shouldSetToAddress(data?.toTokenAddress, data?.fromTokenAddress) && !toToken) {
+            setToToken(allowedTokens.find((token) => (isNativeToken(token.address) && data?.toTokenAddress?.toLowerCase() === NATIVE) || (token.address?.toLowerCase() === data?.toTokenAddress?.toLowerCase())));
+        }
+        setLoadedToAndFromTokens(true);
+    }, [
+        tokenBalances,
+        allowedTokens,
+        cryptoFiatState.conversions,
+        data?.fromTokenAddress,
+        data?.toTokenAddress,
+        setFromToken,
+        setFromBalance,
+        setToToken,
+        setTokensOptionsForm,
+        formatTokenOptionsId,
+        formatZeroAmount,
+        network,
+    ]);
+    const tokensOptionsTo = reactExports.useMemo(() => allowedTokens
+        .map((token) => ({
+        id: formatTokenOptionsId(token.symbol, token.address),
+        name: token.name,
+        symbol: token.symbol,
+        icon: token.icon,
+    })), [allowedTokens, fromToken]);
+    reactExports.useEffect(() => {
+        cryptoFiatDispatch({
+            payload: {
+                type: CryptoFiatActions.SET_TOKEN_SYMBOLS,
+                tokenSymbols: allowedTokens.map((token) => token.symbol),
+            },
+        });
+    }, [cryptoFiatDispatch, allowedTokens]);
+    // ------------------//
+    //    FETCH QUOTES   //
+    // ------------------//
+    const resetFormErrors = () => {
+        setFromAmountError('');
+        setFromTokenError('');
+        setToAmountError('');
+        setToTokenError('');
+    };
+    const resetQuote = () => {
+        if (quoteRequest) {
+            quoteRequest.cancel();
+        }
+        setConversionAmount('');
+        setConversionToken(null);
+        setGasFeeFiatValue('');
+        setQuote(null);
+    };
+    const processFetchQuoteFrom = async (silently = false) => {
+        if (!provider)
+            return;
+        if (!checkout)
+            return;
+        if (!fromToken)
+            return;
+        if (!toToken)
+            return;
+        try {
+            const quoteResultPromise = checkout.swapQuote({
+                provider,
+                fromToken,
+                toToken,
+                fromAmount,
+            });
+            const currentQuoteRequest = CancellablePromise.all([
+                quoteResultPromise,
+            ]);
+            quoteRequest = currentQuoteRequest;
+            const resolved = await currentQuoteRequest;
+            let quoteResult = processGasFree(provider, resolved[0]);
+            quoteResult = processSecondaryFees(fromToken, quoteResult);
+            quoteResult = processQuoteToken(toToken, quoteResult);
+            const estimate = quoteResult.swap.gasFeeEstimate;
+            let gasFeeTotal = BigNumber.from(estimate?.value || 0);
+            if (quoteResult.approval?.gasFeeEstimate) {
+                gasFeeTotal = gasFeeTotal.add(quoteResult.approval.gasFeeEstimate.value);
+            }
+            const gasFee = formatUnits(gasFeeTotal, DEFAULT_TOKEN_DECIMALS);
+            const estimateToken = estimate?.token;
+            const gasToken = allowedTokens.find((token) => token.address?.toLocaleLowerCase() === estimateToken?.address?.toLocaleLowerCase());
+            setConversionToken(fromToken);
+            setConversionAmount(fromAmount);
+            setQuote(quoteResult);
+            setGasFeeValue(gasFee);
+            setGasFeeToken({
+                name: gasToken?.name || '',
+                symbol: gasToken?.symbol || '',
+                decimals: gasToken?.decimals || 0,
+                address: gasToken?.address,
+                icon: gasToken?.icon,
+            });
+            setGasFeeFiatValue(calculateCryptoToFiat(gasFee, gasToken?.symbol || '', cryptoFiatState.conversions));
+            setToAmount(formatZeroAmount(tokenValueFormat(formatUnits(quoteResult.quote.amount.value, quoteResult.quote.amount.token.decimals), quoteResult.quote.amount.token.decimals)));
+            resetFormErrors();
+        }
+        catch (error) {
+            if (!error.cancelled) {
+                // eslint-disable-next-line no-console
+                console.error('Error fetching quote.', error);
+                resetQuote();
+                setShowNotEnoughImxDrawer(false);
+                setShowUnableToSwapDrawer(true);
+            }
+        }
+        if (!silently) {
+            setLoading(false);
+        }
+    };
+    const processFetchQuoteTo = async (silently = false) => {
+        if (!provider)
+            return;
+        if (!checkout)
+            return;
+        if (!fromToken)
+            return;
+        if (!toToken)
+            return;
+        try {
+            const quoteResultPromise = checkout.swapQuote({
+                provider,
+                fromToken,
+                toToken,
+                fromAmount: undefined,
+                toAmount,
+            });
+            const currentQuoteRequest = CancellablePromise.all([
+                quoteResultPromise,
+            ]);
+            quoteRequest = currentQuoteRequest;
+            const resolved = await currentQuoteRequest;
+            let quoteResult = processGasFree(provider, resolved[0]);
+            quoteResult = processSecondaryFees(fromToken, quoteResult);
+            const estimate = quoteResult.swap.gasFeeEstimate;
+            let gasFeeTotal = BigNumber.from(estimate?.value || 0);
+            if (quoteResult.approval?.gasFeeEstimate) {
+                gasFeeTotal = gasFeeTotal.add(quoteResult.approval.gasFeeEstimate.value);
+            }
+            const gasFee = formatUnits(gasFeeTotal, DEFAULT_TOKEN_DECIMALS);
+            const estimateToken = estimate?.token;
+            const gasToken = allowedTokens.find((token) => token.symbol === estimateToken?.symbol);
+            setConversionToken(toToken);
+            setConversionAmount(toAmount);
+            setQuote(quoteResult);
+            setGasFeeValue(gasFee);
+            setGasFeeToken({
+                name: gasToken?.name || '',
+                symbol: gasToken?.symbol || '',
+                decimals: gasToken?.decimals || 0,
+                address: gasToken?.address,
+                icon: gasToken?.icon,
+            });
+            setGasFeeFiatValue(calculateCryptoToFiat(gasFee, gasToken?.symbol || '', cryptoFiatState.conversions));
+            setFromAmount(formatZeroAmount(tokenValueFormat(formatUnits(quoteResult.quote.amount.value, quoteResult.quote.amount.token.decimals))));
+            resetFormErrors();
+        }
+        catch (error) {
+            if (!error.cancelled) {
+                resetQuote();
+                setShowNotEnoughImxDrawer(false);
+                setShowUnableToSwapDrawer(true);
+            }
+        }
+        if (!silently) {
+            setLoading(false);
+        }
+    };
+    const canRunFromQuote = (amount, silently) => {
+        if (Number.isNaN(parseFloat(amount)))
+            return false;
+        if (parseFloat(amount) <= 0)
+            return false;
+        if (!fromToken)
+            return false;
+        if (!toToken)
+            return false;
+        if (silently && loading)
+            return false;
+        return true;
+    };
+    const fetchQuoteFrom = async (silently = false) => {
+        if (!canRunFromQuote(fromAmount, silently))
+            return;
+        // Cancel any existing quote
+        if (quoteRequest) {
+            quoteRequest.cancel();
+        }
+        if (!silently) {
+            setLoading(true);
+        }
+        await processFetchQuoteFrom(silently);
+    };
+    const canRunToQuote = (amount, silently) => {
+        if (Number.isNaN(parseFloat(amount)))
+            return false;
+        if (parseFloat(amount) <= 0)
+            return false;
+        if (!fromToken)
+            return false;
+        if (!toToken)
+            return false;
+        if (silently && loading)
+            return false;
+        return true;
+    };
+    const fetchQuoteTo = async (silently = false) => {
+        if (!canRunToQuote(toAmount, silently))
+            return;
+        // Cancel any existing quote
+        if (quoteRequest) {
+            quoteRequest.cancel();
+        }
+        if (!silently) {
+            setLoading(true);
+        }
+        await processFetchQuoteTo(silently);
+    };
+    const fetchQuote = async (silently = false) => {
+        if (direction === SwapDirection.FROM)
+            await fetchQuoteFrom(silently);
+        else
+            await fetchQuoteTo(silently);
+    };
+    // Silently refresh the quote
+    useInterval(() => {
+        fetchQuote(true);
+    }, DEFAULT_QUOTE_REFRESH_INTERVAL);
+    // Fetch quote triggers
+    reactExports.useEffect(() => {
+        if (direction === SwapDirection.FROM) {
+            if (debouncedFromAmount <= 0) {
+                setLoading(false);
+                resetQuote();
+                return;
+            }
+            (async () => await fetchQuote())();
+        }
+    }, [debouncedFromAmount, fromToken, toToken, fromMaxTrigger]);
+    reactExports.useEffect(() => {
+        if (direction === SwapDirection.TO) {
+            if (debouncedToAmount <= 0) {
+                setLoading(false);
+                resetQuote();
+                return;
+            }
+            (async () => await fetchQuote())();
+        }
+    }, [debouncedToAmount, toToken, fromToken]);
+    // during swaps, having enough IMX to cover the gas fee means (only relevant for non-Passport wallets)
+    // 1. swapping from any token to any token costs IMX - so do a check
+    // 2. If the swap from token is also IMX, include the additional amount into the calc
+    //    as user will need enough imx for the swap amount and the gas
+    const insufficientFundsForGas = reactExports.useMemo(() => {
+        if (!provider)
+            return true;
+        if (isPassportProvider(provider))
+            return false;
+        const imxBalance = tokenBalances.find((b) => b.token.address?.toLowerCase() === NATIVE);
+        if (!imxBalance)
+            return true;
+        const fromTokenIsImx = fromToken?.address?.toLowerCase() === NATIVE;
+        const gasAmount = parseEther(gasFeeValue.length !== 0 ? gasFeeValue : '0');
+        const additionalAmount = fromTokenIsImx && !Number.isNaN(parseFloat(fromAmount))
+            ? parseUnits(fromAmount, fromToken?.decimals || 18)
+            : BigNumber.from('0');
+        return gasAmount.add(additionalAmount).gt(imxBalance.balance);
+    }, [gasFeeValue, tokenBalances, fromToken, fromAmount, provider]);
+    // -------------//
+    //     FROM     //
+    // -------------//
+    reactExports.useEffect(() => {
+        if (!fromAmount)
+            return;
+        if (!fromToken)
+            return;
+        setFromFiatValue(calculateCryptoToFiat(fromAmount, fromToken.symbol, cryptoFiatState.conversions));
+    }, [fromAmount, fromToken, cryptoFiatState.conversions]);
+    const onFromSelectChange = reactExports.useCallback((value) => {
+        const selected = tokenBalances
+            .find((tokenBalance) => value === formatTokenOptionsId(tokenBalance.token.symbol, tokenBalance.token.address));
+        if (!selected)
+            return;
+        if (toToken && value === formatTokenOptionsId(toToken.symbol, toToken?.address)) {
+            setToToken(undefined);
+        }
+        setFromToken(selected.token);
+        setFromBalance(selected.formattedBalance);
+        setFromTokenError('');
+    }, [toToken]);
+    const onFromTextInputFocus = () => {
+        setDirection(SwapDirection.FROM);
+    };
+    const onFromTextInputChange = (value) => {
+        if (value === fromAmount) {
+            return;
+        }
+        resetFormErrors();
+        resetQuote();
+        setToAmount('');
+        if (canRunFromQuote(value, false)) {
+            setLoading(true);
+        }
+        setFromAmount(value);
+    };
+    const textInputMaxButtonClick = () => {
+        if (!fromBalance)
+            return;
+        const fromBalanceTruncated = fromBalance.slice(0, fromBalance.indexOf('.') + DEFAULT_TOKEN_VALIDATION_DECIMALS + 1);
+        resetFormErrors();
+        resetQuote();
+        setDirection(SwapDirection.FROM);
+        setToAmount('');
+        if (canRunFromQuote(fromBalanceTruncated, false)) {
+            setLoading(true);
+        }
+        if (fromAmount === fromBalanceTruncated) {
+            setFromMaxTrigger(fromMaxTrigger + 1);
+        }
+        else {
+            setFromAmount(fromBalanceTruncated);
+        }
+        track({
+            userJourney: UserJourney.SWAP,
+            screen: 'SwapCoins',
+            control: 'MaxFrom',
+            controlType: 'Button',
+            extras: {
+                fromBalance,
+                fromBalanceTruncated,
+            },
+        });
+    };
+    // ------------//
+    //      TO     //
+    // ------------//
+    const onToSelectChange = reactExports.useCallback((value) => {
+        const selected = allowedTokens.find((token) => value === formatTokenOptionsId(token.symbol, token.address));
+        if (!selected)
+            return;
+        if (fromToken && value === formatTokenOptionsId(fromToken.symbol, fromToken?.address)) {
+            setFromToken(undefined);
+        }
+        setToToken(selected);
+        setToTokenError('');
+    }, [fromToken]);
+    const onToTextInputFocus = () => {
+        setDirection(SwapDirection.TO);
+    };
+    const onToTextInputChange = (value) => {
+        if (value === toAmount) {
+            return;
+        }
+        resetFormErrors();
+        resetQuote();
+        setFromFiatValue('');
+        setFromAmount('');
+        if (canRunToQuote(value, false)) {
+            setLoading(true);
+        }
+        setToAmount(value);
+    };
+    const openNotEnoughImxDrawer = () => {
+        setShowUnableToSwapDrawer(false);
+        setShowNotEnoughImxDrawer(true);
+    };
+    const SwapFormValidator = () => {
+        const validateFromTokenError = validateFromToken(fromToken);
+        const validateFromAmountError = validateFromAmount(fromAmount, fromBalance);
+        const validateToTokenError = validateToToken(toToken);
+        const validateToAmountError = validateToAmount(toAmount);
+        if (direction === SwapDirection.FROM) {
+            setToAmountError('');
+            if (validateFromAmountError) {
+                setFromAmountError(validateFromAmountError);
+            }
+        }
+        else if (direction === SwapDirection.TO) {
+            setFromAmountError('');
+            if (validateToAmountError) {
+                setToAmountError(validateToAmountError);
+            }
+        }
+        if (validateFromTokenError)
+            setFromTokenError(validateFromTokenError);
+        if (validateToTokenError)
+            setToTokenError(validateToTokenError);
+        let isSwapFormValid = true;
+        if (validateFromTokenError
+            || validateToTokenError
+            || (validateFromAmountError && direction === SwapDirection.FROM)
+            || (validateToAmountError && direction === SwapDirection.TO))
+            isSwapFormValid = false;
+        track({
+            userJourney: UserJourney.SWAP,
+            screen: 'SwapCoins',
+            control: 'FormValid',
+            controlType: 'Button',
+            extras: {
+                isSwapFormValid,
+                swapFromAddress: fromToken?.address,
+                swapFromAmount: fromAmount,
+                swapFromTokenSymbol: fromToken?.symbol,
+                swapToAddress: toToken?.address,
+                swapToAmount: toAmount,
+                swapToTokenSymbol: toToken?.symbol,
+                autoProceed,
+            },
+        });
+        return isSwapFormValid;
+    };
+    const isFormValidForAutoProceed = reactExports.useMemo(() => {
+        if (!autoProceed)
+            return false;
+        if (loadedToAndFromTokens === false)
+            return false;
+        return !loading;
+    }, [autoProceed, loading, loadedToAndFromTokens]);
+    const canAutoSwap = reactExports.useMemo(() => {
+        if (!autoProceed)
+            return false;
+        if (!isFormValidForAutoProceed)
+            return false;
+        const isFormValid = SwapFormValidator();
+        if (!isFormValid) {
+            cancelAutoProceed();
+            return false;
+        }
+        return true;
+    }, [isFormValidForAutoProceed]);
+    const sendTransaction = async () => {
+        if (!quote)
+            return;
+        if (riskAssessment && isAddressSanctioned(riskAssessment)) {
+            viewDispatch({
+                payload: {
+                    type: ViewActions.UPDATE_VIEW,
+                    view: {
+                        type: SwapWidgetViews.SERVICE_UNAVAILABLE,
+                    },
+                },
+            });
+            return;
+        }
+        const transaction = quote;
+        const isValid = SwapFormValidator();
+        // Tracking swap from data here and is valid or not to understand behaviour
+        track({
+            userJourney: UserJourney.SWAP,
+            screen: 'SwapCoins',
+            control: 'Swap',
+            controlType: 'Button',
+            extras: {
+                swapFromAddress: data?.fromTokenAddress,
+                swapFromAmount: data?.fromAmount,
+                swapFromTokenSymbol: data?.fromTokenSymbol,
+                swapToAddress: data?.toTokenAddress,
+                swapToAmount: data?.toAmount,
+                swapToTokenSymbol: data?.toTokenSymbol,
+                isSwapFormValid: isValid,
+                hasFundsForGas: !insufficientFundsForGas,
+                autoProceed,
+            },
+        });
+        if (!isValid)
+            return;
+        if (!checkout || !provider || !transaction)
+            return;
+        if (insufficientFundsForGas) {
+            cancelAutoProceed();
+            openNotEnoughImxDrawer();
+            return;
+        }
+        try {
+            // check for switch network here
+            const currentChainId = await provider.provider.request({ method: 'eth_chainId', params: [] });
+            // eslint-disable-next-line radix
+            const parsedChainId = parseInt(currentChainId.toString());
+            if (parsedChainId !== getL2ChainId(checkout.config)) {
+                setShowNetworkSwitchDrawer(true);
+                return;
+            }
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error('Current network check failed', err);
+        }
+        if (!transaction)
+            return;
+        setLoading(true);
+        const prefilledSwapData = {
+            fromAmount: data?.fromAmount || '',
+            fromTokenAddress: data?.fromTokenAddress || '',
+            toTokenAddress: data?.toTokenAddress || '',
+            toAmount: data?.toAmount || '',
+        };
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: SwapWidgetViews.APPROVE_ERC20,
+                    data: {
+                        approveTransaction: transaction.approval?.transaction,
+                        transaction: transaction.swap.transaction,
+                        info: transaction.quote,
+                        swapFormInfo: prefilledSwapData,
+                        autoProceed,
+                    },
+                },
+            },
+        });
+    };
+    const shouldSendTransaction = reactExports.useMemo(() => {
+        if (canAutoSwap === true && autoProceed === true) {
+            return true;
+        }
+        return undefined;
+    }, [canAutoSwap, autoProceed]);
+    reactExports.useEffect(() => {
+        if (shouldSendTransaction === undefined)
+            return;
+        sendTransaction();
+    }, [shouldSendTransaction]);
+    return (jsxs(Fragment, { children: [jsxs(Box, { sx: {
+                    visibility: autoProceed ? 'hidden' : 'visible',
+                    paddingX: 'base.spacing.x4',
+                    marginBottom: 'base.spacing.x2',
+                }, children: [jsx(Heading, { size: "small", weight: "regular", sx: { paddingBottom: 'base.spacing.x4' }, children: t('views.SWAP.content.title') }), jsxs(Box, { sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            rowGap: 'base.spacing.x6',
+                            paddingBottom: 'base.spacing.x2',
+                        }, children: [jsxs(Box, { children: [jsx(Heading, { size: "xSmall", sx: {
+                                            display: 'flex',
+                                            justifyContent: 'space-between',
+                                            paddingBottom: 'base.spacing.x1',
+                                        }, children: t('views.SWAP.swapForm.from.label') }), jsx(SelectInput, { testId: "fromTokenInputs", options: tokensOptionsFrom, selectSubtext: fromToken
+                                            ? `${t('views.SWAP.content.availableBalancePrefix')} ${tokenValueFormat(fromBalance)}`
+                                            : '', selectTextAlign: "left", textInputType: "number", testInputMode: "decimal", textInputValue: fromAmount, textInputPlaceholder: t('views.SWAP.swapForm.from.inputPlaceholder'), textInputSubtext: `${t('views.SWAP.content.fiatPricePrefix')} 
+              $${formatZeroAmount(fromFiatValue, true)}`, textInputTextAlign: "right", textInputValidator: amountInputValidation, onTextInputChange: (v) => onFromTextInputChange(v), onTextInputFocus: onFromTextInputFocus, textInputMaxButtonClick: textInputMaxButtonClick, onSelectChange: onFromSelectChange, textInputErrorMessage: t(fromAmountError), selectErrorMessage: t(fromTokenError), selectedOption: fromToken
+                                            ? formatTokenOptionsId(fromToken.symbol, fromToken.address)
+                                            : undefined, coinSelectorHeading: t('views.SWAP.swapForm.from.selectorTitle'), defaultTokenImage: defaultTokenImage, environment: checkout?.config.environment, theme: theme })] }), jsxs(Box, { children: [jsxs(Box, { sx: {
+                                            display: 'flex',
+                                            justifyContent: 'space-between',
+                                            paddingBottom: 'base.spacing.x1',
+                                        }, children: [jsx(Heading, { size: "xSmall", children: t('views.SWAP.swapForm.to.label') }), swapConversionRateTooltip?.length > 0 && (jsxs(Tooltip, { children: [jsx(Tooltip.Target, { children: jsx(Icon, { icon: "InformationCircle", sx: {
+                                                                w: 'base.icon.size.300',
+                                                            } }) }), jsx(Tooltip.Content, { children: swapConversionRateTooltip })] }))] }), jsx(SelectInput, { testId: "toTokenInputs", options: tokensOptionsTo, selectTextAlign: "left", textInputType: "number", testInputMode: "decimal", textInputValue: toAmount, textInputPlaceholder: t('views.SWAP.swapForm.to.inputPlaceholder'), textInputTextAlign: "right", textInputValidator: amountInputValidation, onTextInputChange: (v) => onToTextInputChange(v), onTextInputFocus: onToTextInputFocus, onSelectChange: onToSelectChange, textInputErrorMessage: t(toAmountError), selectErrorMessage: t(toTokenError), selectedOption: toToken
+                                            ? formatTokenOptionsId(toToken.symbol, toToken.address)
+                                            : undefined, coinSelectorHeading: t('views.SWAP.swapForm.to.selectorTitle'), defaultTokenImage: defaultTokenImage, environment: checkout?.config.environment, theme: theme })] })] }), !isPassportProvider(provider) && (jsx(Fees, { gasFeeFiatValue: gasFeeFiatValue, gasFeeToken: gasFeeToken, gasFeeValue: gasFeeValue, fees: formattedFees, onFeesClick: () => {
+                            track({
+                                userJourney: UserJourney.SWAP,
+                                screen: 'SwapCoins',
+                                control: 'ViewFees',
+                                controlType: 'Button',
+                            });
+                        }, sx: {
+                            paddingBottom: '0',
+                        }, loading: loading }))] }), !autoProceed && (jsx(SwapButton, { validator: SwapFormValidator, loading: loading, sendTransaction: sendTransaction })), jsx(TransactionRejected, { visible: showTxnRejectedState, showHeaderBar: false, onCloseDrawer: () => setShowTxnRejectedState(false), onRetry: () => {
+                    sendTransaction();
+                    setShowTxnRejectedState(false);
+                } }), jsx(NotEnoughImx, { environment: checkout?.config.environment ?? Environment.PRODUCTION, visible: showNotEnoughImxDrawer, showAdjustAmount: fromToken?.address === NATIVE, hasZeroImx: false, onAddCoinsClick: () => {
+                    viewDispatch({
+                        payload: {
+                            type: ViewActions.UPDATE_VIEW,
+                            view: {
+                                type: SharedViews.TOP_UP_VIEW,
+                            },
+                            currentViewData: {
+                                fromTokenAddress: fromToken?.address ?? '',
+                                fromAmount,
+                                toTokenAddress: toToken?.address ?? '',
+                            },
+                        },
+                    });
+                }, onCloseDrawer: () => setShowNotEnoughImxDrawer(false) }), jsx(UnableToSwap, { visible: showUnableToSwapDrawer, onCloseDrawer: () => {
+                    setShowUnableToSwapDrawer(false);
+                    setFromToken(undefined);
+                    setFromAmount('');
+                    setToToken(undefined);
+                    setToAmount('');
+                } }), jsx(NetworkSwitchDrawer, { visible: showNetworkSwitchDrawer, targetChainId: getL2ChainId(checkout?.config), provider: provider, checkout: checkout, onCloseDrawer: () => setShowNetworkSwitchDrawer(false) })] }));
+}
+
+const hasZeroBalance = (tokenBalances, symbol) => {
+    if (tokenBalances.length === 0)
+        return true;
+    let zeroBalance = false;
+    tokenBalances
+        .forEach((t) => {
+        if (t.token.symbol === symbol && t.balance.eq(0)) {
+            zeroBalance = true;
+        }
+    });
+    return zeroBalance;
+};
+
+function SwapCoins({ theme, cancelAutoProceed, fromAmount, toAmount, fromTokenAddress, toTokenAddress, showBackButton, }) {
+    const { t } = useTranslation();
+    const { viewDispatch } = reactExports.useContext(ViewContext);
+    const { eventTargetState: { eventTarget } } = reactExports.useContext(EventTargetContext);
+    const { swapState: { tokenBalances, autoProceed, }, } = reactExports.useContext(SwapContext);
+    const { connectLoaderState: { checkout, provider, }, } = reactExports.useContext(ConnectLoaderContext);
+    const [showNotEnoughImxDrawer, setShowNotEnoughImxDrawer] = reactExports.useState(false);
+    const { page } = useAnalytics();
+    reactExports.useEffect(() => {
+        page({
+            userJourney: UserJourney.SWAP,
+            screen: 'SwapCoins',
+            extras: {
+                fromAmount,
+                toAmount,
+                fromTokenAddress,
+                toTokenAddress,
+            },
+        });
+    }, []);
+    reactExports.useEffect(() => {
+        if (hasZeroBalance(tokenBalances, IMX_TOKEN_SYMBOL) && !isPassportProvider(provider)) {
+            setShowNotEnoughImxDrawer(true);
+        }
+    }, [tokenBalances]);
+    return (jsxs(SimpleLayout, { header: !autoProceed ? (jsx(HeaderNavigation, { title: t('views.SWAP.header.title'), onCloseButtonClick: () => sendSwapWidgetCloseEvent(eventTarget), showBack: showBackButton, onBackButtonClick: () => {
+                orchestrationEvents.sendRequestGoBackEvent(eventTarget, IMTBLWidgetEvents.IMTBL_SWAP_WIDGET_EVENT, {});
+            } })) : '', footer: jsx(QuickswapFooter, { environment: checkout?.config.environment, theme: theme }), children: [jsxs(Box, { sx: {
+                    height: '100%',
+                    display: 'flex',
+                    flexDirection: 'column',
+                    justifyContent: 'space-between',
+                }, children: [jsx(SwapForm, { cancelAutoProceed: cancelAutoProceed, data: {
+                            fromAmount,
+                            toAmount,
+                            fromTokenAddress,
+                            toTokenAddress,
+                        }, theme: theme }), jsx(NotEnoughImx, { environment: checkout?.config.environment ?? Environment.PRODUCTION, visible: showNotEnoughImxDrawer, showAdjustAmount: false, hasZeroImx: true, onAddCoinsClick: () => {
+                            viewDispatch({
+                                payload: {
+                                    type: ViewActions.UPDATE_VIEW,
+                                    view: {
+                                        type: SharedViews.TOP_UP_VIEW,
+                                    },
+                                },
+                            });
+                        }, onCloseDrawer: () => {
+                            setShowNotEnoughImxDrawer(false);
+                        } })] }), autoProceed && jsx(LoadingView, { loadingText: t('views.SWAP.PREPARE_SWAP.loading.text') })] }));
+}
+
+function SwapInProgress({ transactionResponse, swapForm, }) {
+    const { t } = useTranslation();
+    const { viewDispatch } = reactExports.useContext(ViewContext);
+    const { page } = useAnalytics();
+    reactExports.useEffect(() => {
+        page({
+            userJourney: UserJourney.SWAP,
+            screen: 'SwapInProgress',
+            extras: {
+                swapFormInfo: swapForm,
+            },
+        });
+    }, []);
+    reactExports.useEffect(() => {
+        (async () => {
+            try {
+                const receipt = await transactionResponse.wait();
+                if (receipt.status === 1) {
+                    viewDispatch({
+                        payload: {
+                            type: ViewActions.UPDATE_VIEW,
+                            view: {
+                                type: SwapWidgetViews.SUCCESS,
+                                data: {
+                                    fromTokenAddress: swapForm.fromTokenAddress,
+                                    fromAmount: swapForm.fromAmount,
+                                    toTokenAddress: swapForm.toTokenAddress,
+                                    toAmount: swapForm.toAmount || '',
+                                    transactionHash: receipt.transactionHash,
+                                },
+                            },
+                        },
+                    });
+                    return;
+                }
+                viewDispatch({
+                    payload: {
+                        type: ViewActions.UPDATE_VIEW,
+                        view: {
+                            type: SwapWidgetViews.FAIL,
+                            data: swapForm,
+                            reason: 'Transaction failed',
+                        },
+                    },
+                });
+            }
+            catch {
+                viewDispatch({
+                    payload: {
+                        type: ViewActions.UPDATE_VIEW,
+                        view: {
+                            type: SwapWidgetViews.FAIL,
+                            data: swapForm,
+                            reason: 'Transaction failed',
+                        },
+                    },
+                });
+            }
+        })();
+    }, [transactionResponse]);
+    return (jsx(LoadingView, { loadingText: t('views.SWAP.IN_PROGRESS.loading.text') }));
+}
+
+function ApproveERC20Onboarding({ data }) {
+    const { t } = useTranslation();
+    const { swapState: { allowedTokens } } = reactExports.useContext(SwapContext);
+    const { connectLoaderState } = reactExports.useContext(ConnectLoaderContext);
+    const { checkout, provider } = connectLoaderState;
+    const { viewDispatch } = reactExports.useContext(ViewContext);
+    const { eventTargetState: { eventTarget } } = reactExports.useContext(EventTargetContext);
+    const isPassport = isPassportProvider(provider);
+    const noApprovalTransaction = data.approveTransaction === undefined;
+    // Local state
+    const [actionDisabled, setActionDisabled] = reactExports.useState(false);
+    const [approvalTxnLoading, setApprovalTxnLoading] = reactExports.useState(false);
+    const [showSwapTxnStep, setShowSwapTxnStep] = reactExports.useState(noApprovalTransaction);
+    const [loading, setLoading] = reactExports.useState(false);
+    // reject transaction flags
+    const [rejectedSpending, setRejectedSpending] = reactExports.useState(false);
+    const [rejectedSwap, setRejectedSwap] = reactExports.useState(false);
+    const { page, track } = useAnalytics();
+    reactExports.useEffect(() => {
+        page({
+            userJourney: UserJourney.SWAP,
+            screen: 'ApproveERC20',
+            extras: {
+                swapFormInfo: data.swapFormInfo,
+            },
+        });
+    }, []);
+    // Get symbol from swap info for approve amount text
+    const fromToken = reactExports.useMemo(() => allowedTokens.find((token) => token.address === data.swapFormInfo.fromTokenAddress), [allowedTokens, data.swapFormInfo.fromTokenAddress]);
+    // Common error view function
+    const showErrorView = reactExports.useCallback(() => {
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: SharedViews.ERROR_VIEW,
+                    error: new Error('No checkout object or no provider object found'),
+                },
+            },
+        });
+    }, [viewDispatch]);
+    const goBackWithSwapData = reactExports.useCallback(() => {
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: SwapWidgetViews.SWAP,
+                    data: data.swapFormInfo,
+                },
+            },
+        });
+    }, [viewDispatch]);
+    const handleExceptions = (err, swapFormData) => {
+        if (err.type === CheckoutErrorType.UNPREDICTABLE_GAS_LIMIT) {
+            viewDispatch({
+                payload: {
+                    type: ViewActions.UPDATE_VIEW,
+                    view: {
+                        type: SwapWidgetViews.PRICE_SURGE,
+                        data: swapFormData,
+                    },
+                },
+            });
+            return;
+        }
+        if (err.type === CheckoutErrorType.TRANSACTION_FAILED
+            || err.type === CheckoutErrorType.INSUFFICIENT_FUNDS
+            || (err.receipt && err.receipt.status === 0)) {
+            viewDispatch({
+                payload: {
+                    type: ViewActions.UPDATE_VIEW,
+                    view: {
+                        type: SwapWidgetViews.FAIL,
+                        reason: 'Transaction failed',
+                        data: swapFormData,
+                    },
+                },
+            });
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.error('Approve ERC20 failed', err);
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: SharedViews.ERROR_VIEW,
+                    error: err,
+                },
+            },
+        });
+    };
+    const prepareTransaction = (transaction, isGasFree = false) => ({
+        ...transaction,
+        gasPrice: (isGasFree ? BigNumber.from(0) : undefined),
+    });
+    /* --------------------- */
+    // Approve spending step //
+    /* --------------------- */
+    const handleApproveSpendingClick = reactExports.useCallback(async () => {
+        if (loading)
+            return;
+        track({
+            userJourney: UserJourney.SWAP,
+            screen: 'ApproveERC20',
+            control: 'ApproveSpending',
+            controlType: 'Button',
+            extras: {
+                autoProceed: data.autoProceed,
+            },
+        });
+        setLoading(true);
+        if (!checkout || !provider) {
+            showErrorView();
+            return;
+        }
+        if (actionDisabled)
+            return;
+        setActionDisabled(true);
+        try {
+            const txnResult = await checkout.sendTransaction({
+                provider,
+                transaction: prepareTransaction(data.approveTransaction, isPassport),
+            });
+            setApprovalTxnLoading(true);
+            const approvalReceipt = await txnResult.transactionResponse.wait();
+            if (approvalReceipt.status !== 1) {
+                viewDispatch({
+                    payload: {
+                        type: ViewActions.UPDATE_VIEW,
+                        view: {
+                            type: SwapWidgetViews.FAIL,
+                            data: data.swapFormInfo,
+                        },
+                    },
+                });
+                return;
+            }
+            setApprovalTxnLoading(false);
+            setActionDisabled(false);
+            setShowSwapTxnStep(true);
+        }
+        catch (err) {
+            setApprovalTxnLoading(false);
+            setActionDisabled(false);
+            if (err.type === CheckoutErrorType.USER_REJECTED_REQUEST_ERROR) {
+                setRejectedSpending(true);
+                return;
+            }
+            handleExceptions(err, data.swapFormInfo);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        checkout,
+        provider,
+        showErrorView,
+        viewDispatch,
+        setRejectedSwap,
+        data.approveTransaction,
+        data.swapFormInfo,
+        actionDisabled,
+        setActionDisabled,
+        setApprovalTxnLoading,
+    ]);
+    const approveSpendingContent = reactExports.useMemo(() => (jsxs(SimpleTextBody, { heading: t(`views.APPROVE_ERC20.approveSpending.content.${isPassport ? 'passport' : 'metamask'}.heading`), children: [isPassport && (jsx(Box, { children: t('views.APPROVE_ERC20.approveSpending.content.passport.body') })), !isPassport
+                // eslint-disable-next-line max-len
+                && (jsx(Box, { children: t('views.APPROVE_ERC20.approveSpending.content.metamask.body', { amount: `${data.swapFormInfo.fromAmount} ${fromToken?.symbol || ''}` }) }))] })), [data.swapFormInfo, fromToken, isPassport]);
+    const approveSpendingFooter = reactExports.useMemo(() => (jsx(FooterButton, { loading: loading, actionText: t(rejectedSpending
+            ? 'views.APPROVE_ERC20.approveSpending.footer.retryText'
+            : 'views.APPROVE_ERC20.approveSpending.footer.buttonText'), onActionClick: handleApproveSpendingClick })), [rejectedSpending, handleApproveSpendingClick, loading]);
+    /* ----------------- */
+    // Approve swap step //
+    /* ----------------- */
+    const handleApproveSwapClick = reactExports.useCallback(async () => {
+        if (loading)
+            return;
+        track({
+            userJourney: UserJourney.SWAP,
+            screen: 'ApproveERC20',
+            control: 'ApproveSwap',
+            controlType: 'Button',
+            extras: {
+                autoProceed: data.autoProceed,
+            },
+        });
+        setLoading(true);
+        if (!checkout || !provider) {
+            showErrorView();
+            return;
+        }
+        if (actionDisabled)
+            return;
+        setActionDisabled(true);
+        try {
+            const txn = await checkout.sendTransaction({
+                provider,
+                transaction: prepareTransaction(data.transaction, isPassport),
+            });
+            setActionDisabled(false);
+            // user approves swap
+            // go to the Swap In Progress View
+            viewDispatch({
+                payload: {
+                    type: ViewActions.UPDATE_VIEW,
+                    view: {
+                        type: SwapWidgetViews.IN_PROGRESS,
+                        data: {
+                            transactionResponse: txn.transactionResponse,
+                            swapForm: data.swapFormInfo,
+                        },
+                    },
+                },
+            });
+        }
+        catch (err) {
+            setActionDisabled(false);
+            if (err.type === CheckoutErrorType.USER_REJECTED_REQUEST_ERROR) {
+                setRejectedSwap(true);
+                return;
+            }
+            handleExceptions(err, data.swapFormInfo);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        checkout,
+        provider,
+        showErrorView,
+        viewDispatch,
+        setRejectedSwap,
+        data.transaction,
+        data.swapFormInfo,
+        actionDisabled,
+        setActionDisabled,
+    ]);
+    const approveSwapContent = (jsx(SimpleTextBody, { heading: t('views.APPROVE_ERC20.approveSwap.content.heading'), children: jsx(Box, { children: t('views.APPROVE_ERC20.approveSwap.content.body') }) }));
+    const approveSwapFooter = reactExports.useMemo(() => (jsx(FooterButton, { loading: loading, actionText: t(rejectedSwap
+            ? 'views.APPROVE_ERC20.approveSwap.footer.retryText'
+            : 'views.APPROVE_ERC20.approveSwap.footer.buttonText'), onActionClick: handleApproveSwapClick })), [rejectedSwap, handleApproveSwapClick, loading]);
+    return (jsxs(Fragment, { children: [approvalTxnLoading && (jsx(LoadingView, { loadingText: t('views.APPROVE_ERC20.approveSpending.loading.text') })), !approvalTxnLoading && (jsx(SimpleLayout, { header: (jsx(HeaderNavigation, { transparent: true, showBack: true, onCloseButtonClick: () => sendSwapWidgetCloseEvent(eventTarget), onBackButtonClick: goBackWithSwapData })), floatHeader: true, heroContent: showSwapTxnStep ? jsx(WalletApproveHero, {}) : jsx(SpendingCapHero, {}), footer: showSwapTxnStep ? approveSwapFooter : approveSpendingFooter, children: showSwapTxnStep ? approveSwapContent : approveSpendingContent }))] }));
+}
+
+function NoServiceHero() {
+    return (jsx(Box, { sx: {
+            ...heroBackGroundStyles,
+            background: 'base.color.translucent.emphasis.100',
+        }, children: jsx(Box, { sx: heroImageStyles, children: jsxs("svg", { width: "430", height: "305", viewBox: "0 0 430 305", fill: "none", xmlns: "http://www.w3.org/2000/svg", xmlnsXlink: "http://www.w3.org/1999/xlink", children: [jsx("path", { d: "M0 0H430V305H0V0Z", fill: "white", fillOpacity: "0.04" }), jsx("mask", { id: "mask0_11507_6650", maskUnits: "userSpaceOnUse", x: "153", y: "80", width: "101", height: "129", children: jsx("path", { d: "M153.179 130.167C153.179 102.559 175.559 80.1792 203.167 80.1792C230.774 80.1792 253.154 102.559 253.154 130.167V208.821H153.179V130.167Z", fill: "#D9D9D9", stroke: "#131313", strokeWidth: "0.358333" }) }), jsxs("g", { mask: "url(#mask0_11507_6650)", children: [jsx("path", { d: "M153.179 130.167C153.179 102.559 175.559 80.1792 203.167 80.1792C230.774 80.1792 253.154 102.559 253.154 130.167V208.821H153.179V130.167Z", fill: "black", stroke: "#131313", strokeWidth: "0.358333" }), jsx("mask", { id: "path-4-inside-1_11507_6650", fill: "white", children: jsx("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M203.305 80C202.053 80 200.812 80.0459 199.583 80.136C221.721 81.8907 239.138 100.411 239.138 123V209H253.472V130.167C253.472 102.46 231.011 80 203.305 80Z" }) }), jsx("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M203.305 80C202.053 80 200.812 80.0459 199.583 80.136C221.721 81.8907 239.138 100.411 239.138 123V209H253.472V130.167C253.472 102.46 231.011 80 203.305 80Z", fill: "url(#pattern0)" }), jsx("path", { d: "M199.583 80.136L199.557 79.7786L199.555 80.4932L199.583 80.136ZM239.138 209H238.78V209.358H239.138V209ZM253.472 209V209.358H253.83V209H253.472ZM199.609 80.4933C200.83 80.4039 202.062 80.3583 203.305 80.3583V79.6417C202.045 79.6417 200.795 79.6878 199.557 79.7786L199.609 80.4933ZM199.555 80.4932C221.508 82.2333 238.78 100.6 238.78 123H239.497C239.497 100.223 221.934 81.5482 199.612 79.7788L199.555 80.4932ZM238.78 123V209H239.497V123H238.78ZM253.472 208.642H239.138V209.358H253.472V208.642ZM253.113 130.167V209H253.83V130.167H253.113ZM203.305 80.3583C230.814 80.3583 253.113 102.658 253.113 130.167H253.83C253.83 102.262 231.209 79.6417 203.305 79.6417V80.3583Z", fill: "#131313", mask: "url(#path-4-inside-1_11507_6650)" })] }), jsx("path", { d: "M153.179 130.167C153.179 102.559 175.559 80.1792 203.167 80.1792C230.774 80.1792 253.154 102.559 253.154 130.167V208.821H153.179V130.167Z", stroke: "#131313", strokeWidth: "0.358333" }), jsx("circle", { cx: "177.49", cy: "151.991", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "177.49", cy: "151.991", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "162.904", cy: "134.934", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "165.413", cy: "120.959", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "185.373", cy: "137.743", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "178.565", cy: "138.102", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "174.139", cy: "135.671", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "174.139", cy: "135.671", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "180.841", cy: "129.405", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "180.841", cy: "129.405", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "176.492", cy: "144.01", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "176.492", cy: "144.01", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "187.294", cy: "132.532", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "187.294", cy: "132.532", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "172.708", cy: "115.475", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "175.217", cy: "101.5", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "195.177", cy: "118.284", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "188.369", cy: "118.642", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "183.943", cy: "116.211", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "183.943", cy: "116.211", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "190.645", cy: "109.945", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "190.645", cy: "109.945", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "186.296", cy: "124.551", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "186.296", cy: "124.551", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "203.777", cy: "173.382", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "203.777", cy: "173.382", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "189.192", cy: "156.325", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "191.7", cy: "142.35", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "211.661", cy: "159.134", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "204.852", cy: "159.493", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "200.426", cy: "157.062", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "200.426", cy: "157.062", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "207.129", cy: "150.795", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "207.129", cy: "150.795", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "202.78", cy: "165.401", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "202.78", cy: "165.401", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "214.527", cy: "134.682", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "214.527", cy: "134.682", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "199.942", cy: "117.625", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "202.45", cy: "103.65", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "222.411", cy: "120.434", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "215.602", cy: "120.793", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "211.176", cy: "118.361", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "211.176", cy: "118.361", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "217.879", cy: "112.096", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "217.879", cy: "112.096", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "213.53", cy: "126.701", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "213.53", cy: "126.701", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "204.098", cy: "185.709", r: "0.358333", transform: "rotate(-90 204.098 185.709)", fill: "#F3F3F3" }), jsx("circle", { cx: "204.098", cy: "185.709", r: "0.358333", transform: "rotate(-90 204.098 185.709)", fill: "#F3F3F3" }), jsx("circle", { cx: "187.042", cy: "200.294", r: "0.358333", transform: "rotate(-90 187.042 200.294)", fill: "#F3F3F3" }), jsx("circle", { cx: "173.067", cy: "197.785", r: "1.43333", transform: "rotate(-90 173.067 197.785)", fill: "#F3F3F3" }), jsx("circle", { cx: "189.851", cy: "177.825", r: "1.075", transform: "rotate(-90 189.851 177.825)", fill: "#F3F3F3" }), jsx("circle", { cx: "190.209", cy: "184.633", r: "0.716667", transform: "rotate(-90 190.209 184.633)", fill: "#F3F3F3" }), jsx("circle", { cx: "187.778", cy: "189.06", r: "0.9976", transform: "rotate(-90 187.778 189.06)", fill: "#F3F3F3" }), jsx("circle", { cx: "187.778", cy: "189.06", r: "0.9976", transform: "rotate(-90 187.778 189.06)", fill: "#F3F3F3" }), jsx("circle", { cx: "181.512", cy: "182.358", r: "0.716667", transform: "rotate(-90 181.512 182.358)", fill: "#F3F3F3" }), jsx("circle", { cx: "181.512", cy: "182.358", r: "0.716667", transform: "rotate(-90 181.512 182.358)", fill: "#F3F3F3" }), jsx("circle", { cx: "196.117", cy: "186.706", r: "0.358333", transform: "rotate(-90 196.117 186.706)", fill: "#F3F3F3" }), jsx("circle", { cx: "196.117", cy: "186.706", r: "0.358333", transform: "rotate(-90 196.117 186.706)", fill: "#F3F3F3" }), jsx("circle", { cx: "170.811", cy: "183.415", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "170.811", cy: "183.415", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "156.225", cy: "166.358", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "158.733", cy: "152.384", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "178.694", cy: "169.168", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "171.886", cy: "169.526", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "167.46", cy: "167.095", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "167.46", cy: "167.095", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "174.162", cy: "160.828", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "174.162", cy: "160.828", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "169.813", cy: "175.434", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "169.813", cy: "175.434", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "222.411", cy: "198.465", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "222.411", cy: "198.465", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "207.825", cy: "181.408", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "210.333", cy: "167.433", r: "1.43333", fill: "#F3F3F3" }), jsx("circle", { cx: "230.294", cy: "184.218", r: "1.075", fill: "#F3F3F3" }), jsx("circle", { cx: "223.486", cy: "184.576", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "219.059", cy: "182.145", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "219.059", cy: "182.145", r: "0.9976", fill: "#F3F3F3" }), jsx("circle", { cx: "225.762", cy: "175.879", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "225.762", cy: "175.879", r: "0.716667", fill: "#F3F3F3" }), jsx("circle", { cx: "221.413", cy: "190.484", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "221.413", cy: "190.484", r: "0.358333", fill: "#F3F3F3" }), jsx("circle", { cx: "202.092", cy: "141.527", r: "0.358333", transform: "rotate(90 202.092 141.527)", fill: "#F3F3F3" }), jsx("circle", { cx: "202.092", cy: "141.527", r: "0.358333", transform: "rotate(90 202.092 141.527)", fill: "#F3F3F3" }), jsx("circle", { cx: "219.148", cy: "126.942", r: "0.358333", transform: "rotate(90 219.148 126.942)", fill: "#F3F3F3" }), jsx("circle", { cx: "233.123", cy: "129.45", r: "1.43333", transform: "rotate(90 233.123 129.45)", fill: "#F3F3F3" }), jsx("circle", { cx: "216.339", cy: "149.41", r: "1.075", transform: "rotate(90 216.339 149.41)", fill: "#F3F3F3" }), jsx("circle", { cx: "215.981", cy: "142.602", r: "0.716667", transform: "rotate(90 215.981 142.602)", fill: "#F3F3F3" }), jsx("circle", { cx: "218.412", cy: "138.176", r: "0.9976", transform: "rotate(90 218.412 138.176)", fill: "#F3F3F3" }), jsx("circle", { cx: "218.412", cy: "138.176", r: "0.9976", transform: "rotate(90 218.412 138.176)", fill: "#F3F3F3" }), jsx("circle", { cx: "224.678", cy: "144.878", r: "0.716667", transform: "rotate(90 224.678 144.878)", fill: "#F3F3F3" }), jsx("circle", { cx: "224.678", cy: "144.878", r: "0.716667", transform: "rotate(90 224.678 144.878)", fill: "#F3F3F3" }), jsx("circle", { cx: "210.073", cy: "140.53", r: "0.358333", transform: "rotate(90 210.073 140.53)", fill: "#F3F3F3" }), jsx("circle", { cx: "210.073", cy: "140.53", r: "0.358333", transform: "rotate(90 210.073 140.53)", fill: "#F3F3F3" }), jsx("rect", { x: "153", y: "209", width: "115", height: "14.3333", fill: "#F3F3F3", stroke: "#131313", strokeWidth: "0.716667" }), jsx("rect", { x: "153", y: "209", width: "14.3333", height: "14.3333", fill: "url(#pattern1)", stroke: "#131313", strokeWidth: "0.716667" }), jsx("rect", { x: "153", y: "237.667", width: "143.667", height: "14.3333", fill: "#F3F3F3", stroke: "#131313", strokeWidth: "0.716667" }), jsx("rect", { x: "153", y: "223.333", width: "129.333", height: "14.3333", fill: "#F3F3F3", stroke: "#131313", strokeWidth: "0.716667" }), jsx("rect", { x: "153", y: "237.667", width: "43", height: "14.3333", fill: "url(#pattern2)", stroke: "#131313", strokeWidth: "0.716667" }), jsx("rect", { x: "153", y: "223.333", width: "28.6667", height: "14.3333", fill: "url(#pattern3)", stroke: "#131313", strokeWidth: "0.716667" }), jsxs("defs", { children: [jsx("pattern", { id: "pattern0", patternContentUnits: "objectBoundingBox", width: "1", height: "1", children: jsx("use", { xlinkHref: "#image0_11507_6650", transform: "matrix(0 0.00360121 -0.00862069 0 1 -0.911676)" }) }), jsx("pattern", { id: "pattern1", patternContentUnits: "objectBoundingBox", width: "1", height: "1", children: jsx("use", { xlinkHref: "#image0_11507_6650", transform: "translate(-2.87931) scale(0.00862069)" }) }), jsx("pattern", { id: "pattern2", patternContentUnits: "objectBoundingBox", width: "1", height: "1", children: jsx("use", { xlinkHref: "#image0_11507_6650", transform: "matrix(0.00287356 0 0 0.00862069 -0.626437 0)" }) }), jsx("pattern", { id: "pattern3", patternContentUnits: "objectBoundingBox", width: "1", height: "1", children: jsx("use", { xlinkHref: "#image0_11507_6650", transform: "matrix(0.00431034 0 0 0.00862069 -1.18966 0)" }) }), jsx("image", { id: "image0_11507_6650", width: "784", height: "116", xlinkHref: "data:image/png;base64,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" })] })] }) }) }));
+}
+
+function ServiceUnavailableToRegionErrorView({ service, onCloseClick, primaryActionText, onPrimaryButtonClick, secondaryActionText, onSecondaryButtonClick, }) {
+    const { t } = useTranslation();
+    return (jsxs(SimpleLayout, { header: jsx(HeaderNavigation, { transparent: true, onCloseButtonClick: onCloseClick }), heroContent: jsx(NoServiceHero, {}), floatHeader: true, footer: jsx(FooterLogo, {}), testId: "service-unavailable-to-region-error-view", children: [jsx(SimpleTextBody, { heading: t(`views.SERVICE_UNAVAILABLE_ERROR_VIEW.heading.${service}`), children: jsx(Trans, { i18nKey: t(`views.SERVICE_UNAVAILABLE_ERROR_VIEW.body.${service}`), components: {
+                        quickswapLink: jsx(Link, { size: "small", rc: jsx("a", { target: "_blank", href: "https://quickswap.exchange", rel: "noreferrer" }) }),
+                        immutableSupport: jsx(Link, { size: "small", rc: jsx("a", { target: "_blank", href: "https://support.immutable.com/", rel: "noreferrer" }) }),
+                    } }) }), jsxs(Box, { testId: "button-container", sx: {
+                    height: '100%',
+                    display: 'flex',
+                    flexDirection: 'column',
+                    justifyContent: 'flex-end',
+                }, children: [primaryActionText && onPrimaryButtonClick && (jsx(Box, { sx: {
+                            paddingX: 'base.spacing.x4',
+                            paddingBottom: 'base.spacing.x2',
+                        }, children: jsx(Button, { sx: { width: '100%' }, testId: "primary-action-button", variant: "primary", size: "large", onClick: onPrimaryButtonClick, children: primaryActionText }) })), secondaryActionText && onSecondaryButtonClick && (jsx(Box, { sx: {
+                            paddingX: 'base.spacing.x4',
+                            paddingBottom: 'base.spacing.x2',
+                        }, children: jsx(Button, { sx: { width: '100%' }, testId: "secondary-action-button", variant: "secondary", size: "large", onClick: onSecondaryButtonClick, children: secondaryActionText }) }))] })] }));
+}
+
+var ServiceType;
+(function (ServiceType) {
+    ServiceType["SWAP"] = "swap";
+    ServiceType["GENERIC"] = "generic";
+    ServiceType["ADD_TOKENS"] = "addTokens";
+})(ServiceType || (ServiceType = {}));
+
+const topUpBridgeOption = (isBridgeEnabled, isNotPassport) => {
+    if (isBridgeEnabled && isNotPassport) {
+        return {
+            textKey: 'views.TOP_UP_VIEW.topUpOptions.bridge.heading',
+            action: () => {
+                orchestrationEvents.sendRequestBridgeEvent(window, IMTBLWidgetEvents.IMTBL_BRIDGE_WIDGET_EVENT, {
+                    tokenAddress: '',
+                    amount: '',
+                });
+            },
+        };
+    }
+    return undefined;
+};
+const topUpOnRampOption = (isOnRampEnabled) => {
+    if (isOnRampEnabled) {
+        return {
+            textKey: 'views.TOP_UP_VIEW.topUpOptions.onramp.heading',
+            action: () => {
+                orchestrationEvents.sendRequestOnrampEvent(window, IMTBLWidgetEvents.IMTBL_ONRAMP_WIDGET_EVENT, {
+                    tokenAddress: '',
+                    amount: '',
+                });
+            },
+        };
+    }
+    return undefined;
+};
+
+function GeoblockLoader({ widget, serviceUnavailableView, checkout, }) {
+    const { t } = useTranslation();
+    const { showLoader, hideLoader, isLoading } = useHandover();
+    const [requested, setRequested] = reactExports.useState(false);
+    const [available, setAvailable] = reactExports.useState(false);
+    reactExports.useEffect(() => {
+        if (!checkout)
+            return;
+        (async () => {
+            try {
+                showLoader({ text: t('views.LOADING_VIEW.text') });
+                setRequested(true);
+                setAvailable(await checkout.isSwapAvailable());
+                hideLoader();
+            }
+            catch {
+                hideLoader();
+                setAvailable(false);
+            }
+        })();
+    }, [checkout]);
+    return (
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    jsx(Fragment, { children: requested && !isLoading && (available
+            ? widget
+            : serviceUnavailableView) }));
+}
+
+function SwapWidget({ amount, fromTokenAddress, toTokenAddress, config, autoProceed, direction, showBackButton, walletProviderName, }) {
+    const { t } = useTranslation();
+    const { eventTargetState: { eventTarget }, } = reactExports.useContext(EventTargetContext);
+    const { environment, theme, isOnRampEnabled, isSwapEnabled, isBridgeEnabled, } = config;
+    const { connectLoaderState: { checkout, provider }, } = reactExports.useContext(ConnectLoaderContext);
+    const [viewState, viewDispatch] = reactExports.useReducer(viewReducer, {
+        ...initialViewState,
+        history: [],
+    });
+    const [swapState, swapDispatch] = reactExports.useReducer(swapReducer, initialSwapState);
+    const { page } = useAnalytics();
+    const [errorViewLoading, setErrorViewLoading] = reactExports.useState(false);
+    const swapReducerValues = reactExports.useMemo(() => ({ swapState, swapDispatch }), [swapState, swapDispatch]);
+    const viewReducerValues = reactExports.useMemo(() => ({ viewState, viewDispatch }), [viewState, viewDispatch]);
+    const showErrorView = reactExports.useCallback((error, tryAgain) => {
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: SharedViews.ERROR_VIEW,
+                    tryAgain,
+                    error,
+                },
+            },
+        });
+    }, [viewDispatch]);
+    const showSwapView = reactExports.useCallback(() => {
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: { type: SwapWidgetViews.SWAP },
+            },
+        });
+    }, [viewDispatch]);
+    const loadBalances = reactExports.useCallback(async () => {
+        if (!checkout)
+            throw new Error('loadBalances: missing checkout');
+        if (!provider)
+            throw new Error('loadBalances: missing provider');
+        try {
+            const tokensAndBalances = await getAllowedBalances({
+                checkout,
+                provider,
+                allowTokenListType: TokenFilterTypes.SWAP,
+            });
+            // Why? Check getAllowedBalances
+            if (tokensAndBalances === undefined)
+                return false;
+            swapDispatch({
+                payload: {
+                    type: SwapActions.SET_ALLOWED_TOKENS,
+                    allowedTokens: tokensAndBalances.allowList.tokens,
+                },
+            });
+            swapDispatch({
+                payload: {
+                    type: SwapActions.SET_TOKEN_BALANCES,
+                    tokenBalances: tokensAndBalances.allowedBalances,
+                },
+            });
+        }
+        catch (err) {
+            if (DEFAULT_BALANCE_RETRY_POLICY.nonRetryable(err)) {
+                showErrorView(err, loadBalances);
+                return false;
+            }
+        }
+        return true;
+    }, [checkout, provider]);
+    reactExports.useEffect(() => {
+        (async () => {
+            if (!checkout || !provider)
+                return;
+            const network = await checkout.getNetworkInfo({ provider });
+            // If the provider's network is not the correct network, return out of this and let the
+            // connect loader handle the switch network functionality
+            if (network.chainId !== getL2ChainId(checkout.config))
+                return;
+            swapDispatch({
+                payload: {
+                    type: SwapActions.SET_NETWORK,
+                    network,
+                },
+            });
+            if (!(await loadBalances()))
+                return;
+            if (viewState.view.type === SharedViews.LOADING_VIEW) {
+                showSwapView();
+            }
+        })();
+    }, [checkout, provider]);
+    reactExports.useEffect(() => {
+        if (!checkout || swapState.riskAssessment) {
+            return;
+        }
+        (async () => {
+            const address = await provider?.getSigner()?.getAddress();
+            if (!address) {
+                return;
+            }
+            const assessment = await fetchRiskAssessment([address], checkout.config);
+            swapDispatch({
+                payload: {
+                    type: SwapActions.SET_RISK_ASSESSMENT,
+                    riskAssessment: assessment,
+                },
+            });
+        })();
+    }, [checkout, provider]);
+    reactExports.useEffect(() => {
+        swapDispatch({
+            payload: {
+                type: SwapActions.SET_AUTO_PROCEED,
+                autoProceed: autoProceed ?? false,
+                direction: direction ?? SwapDirection$1.FROM,
+            },
+        });
+    }, [autoProceed, direction]);
+    const cancelAutoProceed = reactExports.useCallback(() => {
+        if (autoProceed) {
+            swapDispatch({
+                payload: {
+                    type: SwapActions.SET_AUTO_PROCEED,
+                    autoProceed: false,
+                    direction: SwapDirection$1.FROM,
+                },
+            });
+        }
+    }, [autoProceed, swapDispatch]);
+    const fromAmount = direction === SwapDirection$1.FROM || direction == null ? amount : undefined;
+    const toAmount = direction === SwapDirection$1.TO ? amount : undefined;
+    const topUpOptions = reactExports.useMemo(() => {
+        const optionsArray = [];
+        const isNotPassport = !isPassportProvider(provider)
+            || walletProviderName !== WalletProviderName.PASSPORT;
+        const isOnramp = topUpOnRampOption(isOnRampEnabled);
+        if (isOnramp) {
+            optionsArray.push({ ...isOnramp });
+        }
+        const isBridge = topUpBridgeOption(isBridgeEnabled, isNotPassport);
+        if (isBridge) {
+            optionsArray.push({ ...isBridge });
+        }
+        return optionsArray;
+    }, []);
+    return (jsx(GeoblockLoader, { checkout: checkout, widget: (jsx(ViewContext.Provider, { value: viewReducerValues, children: jsx(SwapContext.Provider, { value: swapReducerValues, children: jsxs(CryptoFiatProvider, { environment: environment, children: [viewState.view.type === SharedViews.LOADING_VIEW && (jsx(LoadingView, { loadingText: t('views.LOADING_VIEW.text') })), viewState.view.type === SwapWidgetViews.SWAP && (jsx(SwapCoins, { theme: theme, cancelAutoProceed: cancelAutoProceed, fromAmount: viewState.view.data?.fromAmount ?? fromAmount, toAmount: viewState.view.data?.toAmount ?? toAmount, fromTokenAddress: viewState.view.data?.fromTokenAddress ?? fromTokenAddress, toTokenAddress: viewState.view.data?.toTokenAddress ?? toTokenAddress, showBackButton: showBackButton })), viewState.view.type === SwapWidgetViews.IN_PROGRESS && (jsx(SwapInProgress, { transactionResponse: viewState.view.data.transactionResponse, swapForm: viewState.view.data.swapForm })), viewState.view.type === SwapWidgetViews.APPROVE_ERC20 && (jsx(ApproveERC20Onboarding, { data: viewState.view.data })), viewState.view.type === SwapWidgetViews.SUCCESS && (jsx(StatusView, { statusText: t('views.SWAP.success.text'), actionText: t('views.SWAP.success.actionText'), onRenderEvent: () => {
+                                page({
+                                    userJourney: UserJourney.SWAP,
+                                    screen: 'SwapSuccess',
+                                    extras: {
+                                        fromTokenAddress: viewState.view.data?.fromTokenAddress,
+                                        fromAmount: viewState.view.data?.fromAmount,
+                                        toTokenAddress: viewState.view.data?.toTokenAddress,
+                                        toAmount: viewState.view.data?.toAmount,
+                                    },
+                                });
+                                sendSwapSuccessEvent(eventTarget, viewState.view.data.transactionHash);
+                            }, onActionClick: () => sendSwapWidgetCloseEvent(eventTarget), statusType: StatusType.SUCCESS, testId: "success-view" })), viewState.view.type === SwapWidgetViews.FAIL && (jsx(StatusView, { statusText: t('views.SWAP.failed.text'), actionText: t('views.SWAP.failed.actionText'), onRenderEvent: () => {
+                                page({
+                                    userJourney: UserJourney.SWAP,
+                                    screen: 'SwapFailed',
+                                });
+                                sendSwapFailedEvent(eventTarget, 'Transaction failed');
+                            }, onActionClick: () => {
+                                if (viewState.view.type === SwapWidgetViews.FAIL) {
+                                    viewDispatch({
+                                        payload: {
+                                            type: ViewActions.UPDATE_VIEW,
+                                            view: {
+                                                type: SwapWidgetViews.SWAP,
+                                                data: viewState.view.data,
+                                            },
+                                        },
+                                    });
+                                }
+                            }, statusType: StatusType.FAILURE, onCloseClick: () => sendSwapWidgetCloseEvent(eventTarget), testId: "fail-view" })), viewState.view.type === SwapWidgetViews.PRICE_SURGE && (jsx(StatusView, { statusText: t('views.SWAP.rejected.text'), actionText: t('views.SWAP.rejected.actionText'), onRenderEvent: () => {
+                                page({
+                                    userJourney: UserJourney.SWAP,
+                                    screen: 'PriceSurge',
+                                });
+                                sendSwapRejectedEvent(eventTarget, 'Price surge');
+                            }, onActionClick: () => {
+                                if (viewState.view.type === SwapWidgetViews.PRICE_SURGE) {
+                                    viewDispatch({
+                                        payload: {
+                                            type: ViewActions.UPDATE_VIEW,
+                                            view: {
+                                                type: SwapWidgetViews.SWAP,
+                                                data: viewState.view.data,
+                                            },
+                                        },
+                                    });
+                                }
+                            }, statusType: StatusType.WARNING, onCloseClick: () => sendSwapWidgetCloseEvent(eventTarget), testId: "price-surge-view" })), viewState.view.type === SharedViews.ERROR_VIEW && (jsx(ErrorView, { actionText: t('views.ERROR_VIEW.actionText'), onActionClick: async () => {
+                                setErrorViewLoading(true);
+                                const data = viewState.view;
+                                if (!data.tryAgain) {
+                                    showSwapView();
+                                    setErrorViewLoading(false);
+                                    return;
+                                }
+                                if (await data.tryAgain())
+                                    showSwapView();
+                                setErrorViewLoading(false);
+                            }, onCloseClick: () => sendSwapWidgetCloseEvent(eventTarget), errorEventActionLoading: errorViewLoading })), viewState.view.type === SwapWidgetViews.SERVICE_UNAVAILABLE && (jsx(ServiceUnavailableErrorView, { onCloseClick: () => sendSwapWidgetCloseEvent(eventTarget), onBackButtonClick: () => {
+                                viewDispatch({
+                                    payload: { type: ViewActions.UPDATE_VIEW, view: { type: SwapWidgetViews.SWAP } },
+                                });
+                            } })), viewState.view.type === SharedViews.TOP_UP_VIEW && (jsx(TopUpView, { analytics: { userJourney: UserJourney.SWAP }, checkout: checkout, provider: provider, widgetEvent: IMTBLWidgetEvents.IMTBL_SWAP_WIDGET_EVENT, showOnrampOption: isOnRampEnabled, showSwapOption: isSwapEnabled, showBridgeOption: isBridgeEnabled, onCloseButtonClick: () => sendSwapWidgetCloseEvent(eventTarget) }))] }) }) })), serviceUnavailableView: (jsx(ServiceUnavailableToRegionErrorView, { service: ServiceType.SWAP, onCloseClick: () => sendSwapWidgetCloseEvent(window), primaryActionText: topUpOptions && topUpOptions?.length > 0
+                ? t(topUpOptions[0].textKey)
+                : undefined, onPrimaryButtonClick: topUpOptions && topUpOptions?.length > 0
+                ? topUpOptions[0].action
+                : undefined, secondaryActionText: topUpOptions?.length === 2
+                ? t(topUpOptions[1].textKey)
+                : undefined, onSecondaryButtonClick: topUpOptions?.length === 2
+                ? topUpOptions[1].action
+                : undefined })) }));
+}
+
+export { SwapWidget as default };