@imtbl/sdk 1.53.0-alpha.6 → 1.53.0-alpha.7

package/dist/{blockchain_data-w7eGZtId.js → blockchain_data-DyRQVX7o.js}

@@ -1,5 +1,5 @@
-import { A as APIError, B as BlockchainData } from './index-CfjfP8sn.js';
-import { i as index } from './index-DV0aIGc2.js';
+import { A as APIError, B as BlockchainData } from './index-BPNLUTc8.js';
+import { i as index } from './index-CAD31bOV.js';
 
 var blockchain_data = /*#__PURE__*/Object.freeze({
 	__proto__: null,

package/dist/blockchain_data.js

@@ -1,6 +1,6 @@
-export { A as APIError, B as BlockchainData } from './index-CfjfP8sn.js';
-export { i as Types } from './index-DV0aIGc2.js';
-import './index-CwDvabKl.js';
+export { A as APIError, B as BlockchainData } from './index-BPNLUTc8.js';
+export { i as Types } from './index-CAD31bOV.js';
+import './index-B7tbNRz3.js';
 import 'axios';
 import 'lru-memorise';
 import 'global-const';

package/dist/browser/checkout/{AddFundsWidget-C6ASYdqF.js → AddFundsWidget-ElcJ_L46.js}

@@ -1,5 +1,5 @@
-import { r as reactExports, l as useTranslation, n as jsxs, j as jsx, M as MenuItem, aG as motion, aH as listVariants, aI as listItemVariants, a as Box, a7 as Drawer, V as ViewContext, E as EventTargetContext, p as ViewActions, K as SharedViews, Y as HeaderNavigation, F as orchestrationEvents, I as IMTBLWidgetEvents, bh as amountInputValidation, o as Body, cK as OverflowPopoverMenu, a2 as SimpleLayout, T as TokenFilterTypes, x as getL2ChainId, cL as commonjsGlobal, cM as requireSecp256k1$1, cN as requireLib_commonjs, cO as require$$0$3, cP as requireDist$1, cQ as bech32$2, cR as bnExports$1, cS as require$$0$4, cT as getAugmentedNamespace, cU as require$$0$5, cV as minimalisticAssert, cW as require$$2, cX as hash$6, ah as viewReducer, ai as initialViewState, t as useAnalytics, cY as sendAddFundsCloseEvent, ak as ErrorView, U as UserJourney } from './index-BCU32pT8.js';
-import { T as TextInputForm } from './TextInputForm-DBjNTE6z.js';
+import { r as reactExports, l as useTranslation, o as jsxs, j as jsx, a4 as MenuItem, a_ as motion, a$ as listVariants, b0 as listItemVariants, G as Box, at as Drawer, X as ViewContext, a1 as EventTargetContext, V as ViewActions, p as SharedViews, ak as HeaderNavigation, a7 as orchestrationEvents, I as IMTBLWidgetEvents, bv as amountInputValidation, Y as Body, cR as OverflowPopoverMenu, ao as SimpleLayout, U as TokenFilterTypes, h as getL2ChainId, cS as commonjsGlobal, cT as requireSecp256k1$1, cU as requireLib_commonjs, cV as require$$0$3, cW as requireDist$1, cX as bech32$2, cY as bnExports$1, cZ as require$$0$4, c_ as getAugmentedNamespace, c$ as require$$0$5, d0 as minimalisticAssert, d1 as require$$2, d2 as hash$6, aD as viewReducer, aE as initialViewState, $ as useAnalytics, d3 as sendAddFundsCloseEvent, E as ErrorView, a6 as UserJourney } from './index-_4pTEm9m.js';
+import { T as TextInputForm } from './TextInputForm-4POGFRcV.js';
 
 const initialAddFundsState = {
     checkout: null,

package/dist/browser/checkout/{BridgeWidget-1GH2Y2Gl.js → BridgeWidget-DagFbcal.js}

@@ -1,8 +1,8 @@
-import { bz as axios, bA as defineReadOnly, bB as getStatic, bC as Signer, bD as Provider, bE as getAddress, bF as Logger, bG as getContractAddress, bH as Interface, bI as shallowCopy, bJ as VoidSigner, bK as Indexed, bL as deepCopy, bM as isHexString, bN as checkResultErrors, bO as resolveProperties, ar as BigNumber, bP as accessListify, bQ as arrayify, j as jsx, _ as _objectWithoutProperties, ap as cloneElementWithCssProp, o as Body, k as _defineProperty, J as CheckoutErrorType, bR as IMMUTABLE_API_BASE_URL, r as reactExports, I as IMTBLWidgetEvents, b0 as BridgeEventType, n as jsxs, bS as ShimmerBox, M as MenuItem, aL as Stack, l as useTranslation, d as Button, a as Box, bT as PASSPORT_URL, ag as Link, bU as getChainIdBySlug, P as getChainImage, bV as networkName, O as FramedImage, bd as Icon, t as useAnalytics, U as UserJourney, aN as Divider, V as ViewContext, aB as Fragment, p as ViewActions, a8 as useWalletConnect, aa as isWalletConnectProvider, bc as Logo, bW as RawImage, bX as AXELAR_SCAN_URL, G as isNativeToken, W as getTokenImageByAddress, bY as getNativeSymbolByChainSlug, X as calculateCryptoToFiat, E as EventTargetContext, w as isPassportProvider, y as getL1ChainId, T as TokenFilterTypes, x as getL2ChainId, bZ as WalletProviderRdns, b_ as Web3Provider, b$ as useInjectedProviders, Y as HeaderNavigation, a1 as FooterLogo, c0 as WalletDrawer, a2 as SimpleLayout, c1 as getChainSlugById, c2 as JsonRpcProvider, c3 as DEFAULT_TRANSACTIONS_RETRY_POLICY, aj as LoadingView, aX as ChainId, c4 as getChainNameById, u as useTheme, a6 as Heading, a4 as getWalletProviderNameByProvider, c5 as isAddressSanctioned, K as SharedViews, c6 as isMetaMaskProvider, a3 as WalletProviderName, a7 as Drawer, B as ButtCon, $ as ButtonNavigationStyles, F as orchestrationEvents, A as tokenValueFormat, v as formatZeroAmount, bf as NATIVE, bh as amountInputValidation, b6 as getRemoteImage, bb as CloudImage, c7 as ETH_TOKEN_SYMBOL, z as Environment, c8 as GasEstimateType, bl as DEFAULT_TOKEN_DECIMALS, bg as DEFAULT_QUOTE_REFRESH_INTERVAL, c9 as addChainChangedListener, ca as removeChainChangedListener, bn as IMX_TOKEN_SYMBOL, cb as dist, cc as CHECKOUT_CDN_BASE_URL, ab as heroBackGroundStyles, ac as heroImageStyles, cd as Badge, ae as SimpleTextBody, bo as FooterButton, ce as getEthTokenImage, cf as WITHDRAWAL_CLAIM_GAS_LIMIT, be as getDefaultTokenImage, ah as viewReducer, ai as initialViewState, cg as BridgeConfiguration, ch as ImmutableConfiguration, ci as TokenBridge, bq as StatusView, aJ as StatusType, ak as ErrorView, cj as ServiceUnavailableErrorView, ck as ServiceType, cl as ETH_SEPOLIA_TO_ZKEVM_TESTNET, cm as ETH_SEPOLIA_TO_ZKEVM_DEVNET, cn as ETH_MAINNET_TO_ZKEVM_MAINNET } from './index-BCU32pT8.js';
-import { B as BridgeWidgetViews, C as CryptoFiatContext, f as formatUnits, a as CryptoFiatActions, p as parseUnits, T as TopUpView, b as CryptoFiatProvider } from './TopUpView-CIYLtGDm.js';
-import { T as TokenImage, r as retry, u as useInterval } from './retry-B3DoYkeU.js';
-import { A as Accordion, S as SelectForm, T as TransactionRejected, g as getAllowedBalances, F as Fees, N as NetworkSwitchDrawer, W as WalletApproveHero } from './balance-CQ6fP7av.js';
-import { T as TextInputForm } from './TextInputForm-DBjNTE6z.js';
+import { bN as axios, bO as defineReadOnly, bP as getStatic, bQ as Signer, bR as Provider, bS as getAddress, bT as Logger, bU as getContractAddress, bV as Interface, bW as shallowCopy, bX as VoidSigner, bY as Indexed, bZ as deepCopy, b_ as isHexString, b$ as checkResultErrors, c0 as resolveProperties, aL as BigNumber, c1 as accessListify, c2 as arrayify, j as jsx, _ as _objectWithoutProperties, aJ as cloneElementWithCssProp, Y as Body, T as _defineProperty, ab as CheckoutErrorType, c3 as IMMUTABLE_API_BASE_URL, r as reactExports, I as IMTBLWidgetEvents, B as BridgeEventType, o as jsxs, c4 as ShimmerBox, a4 as MenuItem, b3 as Stack, l as useTranslation, N as Button, G as Box, c5 as PASSPORT_URL, aC as Link, c6 as getChainIdBySlug, af as getChainImage, c7 as networkName, ae as FramedImage, br as Icon, $ as useAnalytics, a6 as UserJourney, b5 as Divider, X as ViewContext, aV as Fragment, V as ViewActions, au as useWalletConnect, aw as isWalletConnectProvider, bq as Logo, c8 as RawImage, c9 as AXELAR_SCAN_URL, a9 as isNativeToken, ai as getTokenImageByAddress, ca as getNativeSymbolByChainSlug, aj as calculateCryptoToFiat, a1 as EventTargetContext, a2 as isPassportProvider, i as getL1ChainId, U as TokenFilterTypes, h as getL2ChainId, cb as WalletProviderRdns, cc as Web3Provider, cd as useInjectedProviders, ak as HeaderNavigation, an as FooterLogo, ce as WalletDrawer, ao as SimpleLayout, cf as getChainSlugById, cg as JsonRpcProvider, ch as DEFAULT_TRANSACTIONS_RETRY_POLICY, L as LoadingView, k as ChainId, ci as getChainNameById, w as useTheme, as as Heading, aq as getWalletProviderNameByProvider, cj as isAddressSanctioned, p as SharedViews, ck as isMetaMaskProvider, ap as WalletProviderName, at as Drawer, v as ButtCon, al as ButtonNavigationStyles, a7 as orchestrationEvents, a5 as tokenValueFormat, a0 as formatZeroAmount, bt as NATIVE, bv as amountInputValidation, bk as getRemoteImage, bp as CloudImage, cl as ETH_TOKEN_SYMBOL, a3 as Environment, cm as GasEstimateType, bz as DEFAULT_TOKEN_DECIMALS, bu as DEFAULT_QUOTE_REFRESH_INTERVAL, cn as addChainChangedListener, co as removeChainChangedListener, bB as IMX_TOKEN_SYMBOL, cp as dist, cq as CHECKOUT_CDN_BASE_URL, ax as heroBackGroundStyles, ay as heroImageStyles, cr as Badge, aA as SimpleTextBody, bC as FooterButton, cs as getEthTokenImage, ct as WITHDRAWAL_CLAIM_GAS_LIMIT, bs as getDefaultTokenImage, aD as viewReducer, aE as initialViewState, cu as BridgeConfiguration, cv as ImmutableConfiguration, cw as TokenBridge, bE as StatusView, b1 as StatusType, E as ErrorView, cx as ServiceUnavailableErrorView, cy as ServiceType, cz as ETH_SEPOLIA_TO_ZKEVM_TESTNET, cA as ETH_SEPOLIA_TO_ZKEVM_DEVNET, cB as ETH_MAINNET_TO_ZKEVM_MAINNET } from './index-_4pTEm9m.js';
+import { B as BridgeWidgetViews, C as CryptoFiatContext, f as formatUnits, a as CryptoFiatActions, p as parseUnits, T as TopUpView, b as CryptoFiatProvider } from './TopUpView-DrTM31Ek.js';
+import { T as TokenImage, r as retry, u as useInterval } from './retry-BpGE5FcR.js';
+import { A as Accordion, S as SelectForm, T as TransactionRejected, g as getAllowedBalances, F as Fees, N as NetworkSwitchDrawer, W as WalletApproveHero } from './balance-Bj7GdprK.js';
+import { T as TextInputForm } from './TextInputForm-4POGFRcV.js';
 
 // This module is intended to unwrap Axios default export as named.
 // Keep top-level export same with static properties

package/dist/browser/checkout/CheckoutWidget-BF_Ofszq.js

@@ -0,0 +1,572 @@
+import { r as reactExports, u as useConnectLoaderState, j as jsx, I as IMTBLWidgetEvents, C as CheckoutFlowType, P as ProviderEventType, a as CheckoutEventType, b as ConnectEventType, c as CheckoutFailureEventType, d as CheckoutSuccessEventType, W as WalletEventType, e as CheckoutUserActionEventType, S as SwapEventType, B as BridgeEventType, O as OnRampEventType, f as SaleEventType, g as OrchestrationEventType, V as ViewActions, h as getL2ChainId, i as getL1ChainId, k as ChainId, l as useTranslation, m as useViewState, n as useEventTargetState, o as jsxs, p as SharedViews, L as LoadingView, E as ErrorView, q as ConnectWidget, s as ConnectLoader, t as ViewContextProvider } from './index-_4pTEm9m.js';
+import SwapWidget from './SwapWidget-hn-faHAD.js';
+import { B as BridgeWidget } from './BridgeWidget-DagFbcal.js';
+import { O as OnRampWidget } from './OnRampWidget-9xY2PrDk.js';
+import WalletWidget from './WalletWidget-DVoiXUbf.js';
+import SaleWidget from './SaleWidget-E0v88XfM.js';
+import AddFundsWidget from './AddFundsWidget-ElcJ_L46.js';
+import './balance-Bj7GdprK.js';
+import './retry-BpGE5FcR.js';
+import './TopUpView-DrTM31Ek.js';
+import './TextInputForm-4POGFRcV.js';
+import './SpendingCapHero-B1bghRag.js';
+
+const initialCheckoutState = {
+    checkout: undefined,
+    provider: undefined,
+    passport: undefined,
+};
+var CheckoutActions;
+(function (CheckoutActions) {
+    CheckoutActions["SET_CHECKOUT"] = "SET_CHECKOUT";
+    CheckoutActions["SET_PROVIDER"] = "SET_PROVIDER";
+    CheckoutActions["SET_PASSPORT"] = "SET_PASSPORT";
+})(CheckoutActions || (CheckoutActions = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const CheckoutContext = reactExports.createContext({
+    checkoutState: initialCheckoutState,
+    checkoutDispatch: () => { },
+});
+CheckoutContext.displayName = 'CheckoutContext'; // help with debugging Context in browser
+const checkoutReducer = (state, action) => {
+    switch (action.payload.type) {
+        case CheckoutActions.SET_CHECKOUT:
+            return {
+                ...state,
+                checkout: action.payload.checkout,
+            };
+        case CheckoutActions.SET_PROVIDER:
+            return {
+                ...state,
+                provider: action.payload.provider,
+            };
+        case CheckoutActions.SET_PASSPORT:
+            return {
+                ...state,
+                passport: action.payload.passport,
+            };
+        default:
+            return state;
+    }
+};
+
+const useCheckoutWidgetState = () => {
+    const [viewState, viewDispatch] = reactExports.useReducer(checkoutReducer, initialCheckoutState);
+    return [viewState, viewDispatch];
+};
+function CheckoutWidgetContextProvicer({ children, }) {
+    const [{ checkout, provider }] = useConnectLoaderState();
+    const [checkoutState, checkoutDispatch] = useCheckoutWidgetState();
+    const values = reactExports.useMemo(() => ({
+        checkoutState: { ...checkoutState, checkout, provider },
+        checkoutDispatch,
+    }), [checkoutState, checkoutDispatch, checkout, provider]);
+    return (jsx(CheckoutContext.Provider, { value: values, children: children }));
+}
+
+const sendCheckoutEvent = (eventTarget, detail) => {
+    const event = new CustomEvent(IMTBLWidgetEvents.IMTBL_CHECKOUT_WIDGET_EVENT, { detail });
+    // eslint-disable-next-line no-console
+    console.log('checkout app event ', eventTarget, event);
+    if (eventTarget !== undefined)
+        eventTarget.dispatchEvent(event);
+};
+
+/**
+ * List of views that require a connected wallet
+ */
+const connectFirstViewList = [
+    CheckoutFlowType.SALE,
+    CheckoutFlowType.SWAP,
+    CheckoutFlowType.WALLET,
+    CheckoutFlowType.ONRAMP,
+    CheckoutFlowType.ADD_FUNDS,
+];
+/**
+ * Check if the given view requires a connected wallet
+ */
+function getViewShouldConnect(view) {
+    return connectFirstViewList.includes(view);
+}
+
+/**
+ * Map Connect Widget Events
+ */
+function mapConnectWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case ConnectEventType.SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.CONNECT_SUCCESS,
+                    data,
+                },
+            };
+        case ConnectEventType.FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.CONNECT_FAILED,
+                    data,
+                },
+            };
+        case ConnectEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        default:
+            throw new Error(`Unknown connect event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map Wallet Widget Events
+ */
+function mapWalletWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case WalletEventType.NETWORK_SWITCH:
+            return {
+                type: CheckoutEventType.USER_ACTION,
+                data: {
+                    type: CheckoutUserActionEventType.NETWORK_SWITCH,
+                    data,
+                },
+            };
+        case WalletEventType.DISCONNECT_WALLET:
+            return {
+                type: CheckoutEventType.DISCONNECTED,
+                data: {},
+            };
+        case WalletEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        default:
+            throw new Error(`Unknown wallet event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map Swap Widget Events
+ */
+function mapSwapWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case SwapEventType.SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.SWAP_SUCCESS,
+                    data,
+                },
+            };
+        case SwapEventType.FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.SWAP_FAILED,
+                    data,
+                },
+            };
+        case SwapEventType.REJECTED:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.SWAP_REJECTED,
+                    data,
+                },
+            };
+        case SwapEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        default:
+            throw new Error(`Unknown swap event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map Add Funds Widget Events
+ */
+function mapAddFundsWidgetEvent(event) {
+    const { type } = event.detail;
+    switch (type) {
+        default:
+            throw new Error(`Unknown add funds event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map Bridge Widget Events
+ */
+function mapBridgeWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case BridgeEventType.TRANSACTION_SENT:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.BRIDGE_SUCCESS,
+                    data,
+                },
+            };
+        case BridgeEventType.CLAIM_WITHDRAWAL_SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.BRIDGE_CLAIM_WITHDRAWAL_SUCCESS,
+                    data,
+                },
+            };
+        case BridgeEventType.CLAIM_WITHDRAWAL_FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.BRIDGE_CLAIM_WITHDRAWAL_FAILED,
+                    data,
+                },
+            };
+        case BridgeEventType.FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.BRIDGE_FAILED,
+                    data,
+                },
+            };
+        case BridgeEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        default:
+            throw new Error(`Unknown bridge event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map Bridge Widget Events
+ */
+function mapOnrampWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case OnRampEventType.SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.ONRAMP_SUCCESS,
+                    data,
+                },
+            };
+        case OnRampEventType.FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.ONRAMP_FAILED,
+                    data,
+                },
+            };
+        case OnRampEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        default:
+            throw new Error(`Unknown onRamp event type "${event.detail.type}"`);
+    }
+}
+function mapSaleWidgetEvent(event) {
+    const { type, data } = event.detail;
+    switch (type) {
+        case SaleEventType.SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.SALE_SUCCESS,
+                    data,
+                },
+            };
+        case SaleEventType.FAILURE:
+            return {
+                type: CheckoutEventType.FAILURE,
+                data: {
+                    type: CheckoutFailureEventType.SALE_FAILED,
+                    data,
+                },
+            };
+        case SaleEventType.CLOSE_WIDGET:
+            return {
+                type: CheckoutEventType.CLOSE,
+                data: {},
+            };
+        case SaleEventType.TRANSACTION_SUCCESS:
+            return {
+                type: CheckoutEventType.SUCCESS,
+                data: {
+                    type: CheckoutSuccessEventType.SALE_TRANSACTION_SUCCESS,
+                    data,
+                },
+            };
+        case SaleEventType.PAYMENT_METHOD:
+            return {
+                type: CheckoutEventType.USER_ACTION,
+                data: {
+                    type: CheckoutUserActionEventType.PAYMENT_METHOD_SELECTED,
+                    data,
+                },
+            };
+        case SaleEventType.PAYMENT_TOKEN:
+            return {
+                type: CheckoutEventType.USER_ACTION,
+                data: {
+                    type: CheckoutUserActionEventType.PAYMENT_TOKEN_SELECTED,
+                    data,
+                },
+            };
+        default:
+            throw new Error(`Unknown sale event type "${event.detail.type}"`);
+    }
+}
+/**
+ * Map widget events to checkout widget event detail
+ */
+function getCheckoutWidgetEvent(event) {
+    if (event.detail.type === ProviderEventType.PROVIDER_UPDATED) {
+        return {
+            type: CheckoutEventType.PROVIDER_UPDATED,
+            data: event.detail.data,
+        };
+    }
+    switch (event.type) {
+        case IMTBLWidgetEvents.IMTBL_CONNECT_WIDGET_EVENT:
+            return mapConnectWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_WALLET_WIDGET_EVENT:
+            return mapWalletWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_SWAP_WIDGET_EVENT:
+            return mapSwapWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_ADD_FUNDS_WIDGET_EVENT:
+            return mapAddFundsWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_BRIDGE_WIDGET_EVENT:
+            return mapBridgeWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_ONRAMP_WIDGET_EVENT:
+            return mapOnrampWidgetEvent(event);
+        case IMTBLWidgetEvents.IMTBL_SALE_WIDGET_EVENT:
+            return mapSaleWidgetEvent(event);
+        default:
+            throw new Error(`Unknown widget event type "${event.type}"`);
+    }
+}
+
+/**
+ * Get view from orchestration event type
+ */
+function getViewFromOrchestrationEventType(type) {
+    switch (type) {
+        case OrchestrationEventType.REQUEST_SWAP:
+            return CheckoutFlowType.SWAP;
+        case OrchestrationEventType.REQUEST_CONNECT:
+            return CheckoutFlowType.CONNECT;
+        case OrchestrationEventType.REQUEST_WALLET:
+            return CheckoutFlowType.WALLET;
+        case OrchestrationEventType.REQUEST_BRIDGE:
+            return CheckoutFlowType.BRIDGE;
+        case OrchestrationEventType.REQUEST_ONRAMP:
+            return CheckoutFlowType.ONRAMP;
+        case OrchestrationEventType.REQUEST_ADD_FUNDS:
+            return CheckoutFlowType.ADD_FUNDS;
+        default:
+            return null;
+    }
+}
+
+/** Orchestration Events List */
+const orchestrationEvents = [
+    OrchestrationEventType.REQUEST_CONNECT,
+    OrchestrationEventType.REQUEST_WALLET,
+    OrchestrationEventType.REQUEST_SWAP,
+    OrchestrationEventType.REQUEST_BRIDGE,
+    OrchestrationEventType.REQUEST_ONRAMP,
+    OrchestrationEventType.REQUEST_ADD_FUNDS,
+    OrchestrationEventType.REQUEST_GO_BACK,
+];
+/**
+ * Check if event is orchestration event
+ */
+function isOrchestrationEvent(event) {
+    return orchestrationEvents.includes(event.detail.type);
+}
+
+/** Widget Events List */
+const widgetEvents = [
+    IMTBLWidgetEvents.IMTBL_CONNECT_WIDGET_EVENT,
+    IMTBLWidgetEvents.IMTBL_WALLET_WIDGET_EVENT,
+    IMTBLWidgetEvents.IMTBL_SWAP_WIDGET_EVENT,
+    IMTBLWidgetEvents.IMTBL_BRIDGE_WIDGET_EVENT,
+    IMTBLWidgetEvents.IMTBL_ONRAMP_WIDGET_EVENT,
+    IMTBLWidgetEvents.IMTBL_SALE_WIDGET_EVENT,
+];
+/**
+ * Subscribe and Handle widget events
+ */
+function useWidgetEvents(eventTarget, viewState) {
+    const [{ history }, viewDispatch] = viewState;
+    /**
+     * Change view as per orchestration event requests
+     */
+    const handleOrchestrationEvent = (event) => {
+        const { type, data } = event.detail;
+        if (type === OrchestrationEventType.REQUEST_GO_BACK) {
+            viewDispatch({
+                payload: {
+                    type: ViewActions.UPDATE_VIEW,
+                    view: history?.[0],
+                },
+            });
+            return;
+        }
+        const flow = getViewFromOrchestrationEventType(type);
+        if (!flow)
+            return;
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: flow,
+                    data: { params: data, config: {}, showBackButton: true },
+                },
+            },
+        });
+    };
+    /**
+     * Proxy widget events to checkout widget events
+     */
+    const handleWidgetEvent = reactExports.useMemo(() => {
+        if (!eventTarget)
+            return null;
+        return (event) => {
+            const customEvent = event;
+            if (isOrchestrationEvent(customEvent)) {
+                handleOrchestrationEvent(customEvent);
+                return;
+            }
+            const eventDetail = getCheckoutWidgetEvent(customEvent);
+            sendCheckoutEvent(eventTarget, eventDetail);
+        };
+    }, [eventTarget]);
+    reactExports.useEffect(() => {
+        if (!handleWidgetEvent)
+            return () => { };
+        widgetEvents.map((event) => window.addEventListener(event, handleWidgetEvent));
+        return () => {
+            widgetEvents.map((event) => window.removeEventListener(event, handleWidgetEvent));
+        };
+    }, [handleWidgetEvent]);
+}
+
+/**
+ * Get the chain id for the checkout
+ */
+const getChainId = (checkout) => (checkout.config.isProduction
+    ? ChainId.IMTBL_ZKEVM_MAINNET
+    : ChainId.IMTBL_ZKEVM_TESTNET);
+/**
+ * Get the connect loader params for the widget
+ */
+function getConnectLoaderParams(view, checkout, web3Provider) {
+    const { type, data } = view;
+    switch (type) {
+        case CheckoutFlowType.WALLET:
+            return {
+                checkout,
+                web3Provider,
+                targetChainId: getChainId(checkout),
+                walletProviderName: data.params.walletProviderName,
+                allowedChains: [
+                    getL1ChainId(checkout.config),
+                    getL2ChainId(checkout.config),
+                ],
+            };
+        case CheckoutFlowType.ONRAMP:
+        case CheckoutFlowType.ADD_FUNDS:
+            return {
+                checkout,
+                web3Provider,
+                targetChainId: getChainId(checkout),
+                allowedChains: [
+                    getL1ChainId(checkout.config),
+                    getL2ChainId(checkout.config),
+                ],
+            };
+        case CheckoutFlowType.SALE:
+        case CheckoutFlowType.SWAP:
+            return {
+                checkout,
+                web3Provider,
+                targetChainId: getChainId(checkout),
+                allowedChains: [getL2ChainId(checkout.config)],
+            };
+        default:
+            return {};
+    }
+}
+
+function CheckoutWidget(props) {
+    const { flowParams, flowConfig, widgetsConfig, checkout, web3Provider, } = props;
+    const { t } = useTranslation();
+    const viewState = useViewState();
+    const [{ view }, viewDispatch] = viewState;
+    const [{ eventTarget }] = useEventTargetState();
+    const connectLoaderParams = reactExports.useMemo(() => getConnectLoaderParams(view, checkout, web3Provider), [view, checkout, web3Provider]);
+    /**
+     * Subscribe and Handle widget events
+     */
+    useWidgetEvents(eventTarget, viewState);
+    /**
+     * Mount the view according to set flow in params
+     */
+    reactExports.useEffect(() => {
+        if (!flowParams.flow)
+            return;
+        const { flow, ...mountedWidgetParams } = flowParams;
+        viewDispatch({
+            payload: {
+                type: ViewActions.UPDATE_VIEW,
+                view: {
+                    type: flow,
+                    data: {
+                        params: mountedWidgetParams,
+                        config: { ...(flowConfig?.[flow] || {}) },
+                    },
+                },
+            },
+        });
+    }, [flowParams]);
+    const showBackButton = !!view.data?.showBackButton;
+    const shouldConnectView = reactExports.useMemo(() => getViewShouldConnect(view.type), [view.type]);
+    return (jsx(ViewContextProvider, { children: jsxs(CheckoutWidgetContextProvicer, { children: [view.type === SharedViews.LOADING_VIEW && (jsx(LoadingView, { loadingText: t('views.LOADING_VIEW.text') })), view.type === SharedViews.SERVICE_UNAVAILABLE_ERROR_VIEW && (jsx(ErrorView, { onCloseClick: () => {
+                        sendCheckoutEvent(eventTarget, {
+                            type: CheckoutEventType.CLOSE,
+                            data: {},
+                        });
+                    }, onActionClick: () => {
+                        // TODO: trigger a retry
+                    }, actionText: t('views.ERROR_VIEW.actionText') })), view.type === CheckoutFlowType.CONNECT && (jsx(ConnectWidget, { config: widgetsConfig, checkout: checkout, sendCloseEventOverride: () => {
+                        sendCheckoutEvent(eventTarget, {
+                            type: CheckoutEventType.CLOSE,
+                            data: {},
+                        });
+                    }, ...(view.data.params || {}) })), view.type === CheckoutFlowType.BRIDGE && (jsx(BridgeWidget, { config: widgetsConfig, checkout: checkout, web3Provider: web3Provider, showBackButton: showBackButton, ...(view.data.params || {}) })), shouldConnectView && (jsx(ConnectLoader, { widgetConfig: widgetsConfig, params: connectLoaderParams, closeEvent: () => {
+                        sendCheckoutEvent(eventTarget, {
+                            type: CheckoutEventType.CLOSE,
+                            data: {},
+                        });
+                    }, children: jsxs(reactExports.Suspense, { fallback: jsx(LoadingView, { loadingText: t('views.LOADING_VIEW.text') }), children: [view.type === CheckoutFlowType.WALLET && (jsx(WalletWidget, { config: widgetsConfig, walletConfig: {
+                                    showNetworkMenu: true,
+                                    showDisconnectButton: true,
+                                    ...view.data.config,
+                                }, ...(view.data.params || {}) })), view.type === CheckoutFlowType.SALE && (jsx(SaleWidget, { config: widgetsConfig, ...(view.data.params || {}), hideExcludedPaymentTypes: false,
+                                waitFulfillmentSettlements: true,
+                                ...view.data.config })), view.type === CheckoutFlowType.ADD_FUNDS && (jsx(AddFundsWidget, { checkout: checkout, ...(view.data.params || {}), ...(view.data.config || {}), showBackButton: showBackButton })), view.type === CheckoutFlowType.SWAP && (jsx(SwapWidget, { config: widgetsConfig, ...(view.data.params || {}), ...(view.data.config || {}), showBackButton: showBackButton })), view.type === CheckoutFlowType.ONRAMP && (jsx(OnRampWidget, { config: widgetsConfig, ...(view.data.params || {}), ...(view.data.config || {}), showBackButton: showBackButton }))] }) }))] }) }));
+}
+
+export { CheckoutWidget as default };

package/dist/browser/checkout/{OnRampWidget-MPFsrkh0.js → OnRampWidget-9xY2PrDk.js}

@@ -1,6 +1,6 @@
-import { bu as global, t as useAnalytics, r as reactExports, q as ConnectLoaderContext, E as EventTargetContext, l as useTranslation, V as ViewContext, K as SharedViews, bv as ExchangeType, j as jsx, a2 as SimpleLayout, Y as HeaderNavigation, bw as sendOnRampWidgetCloseEvent, F as orchestrationEvents, I as IMTBLWidgetEvents, a as Box, U as UserJourney, p as ViewActions, a1 as FooterLogo, n as jsxs, ae as SimpleTextBody, ah as viewReducer, ai as initialViewState, bf as NATIVE, aj as LoadingView, bx as sendOnRampSuccessEvent, aJ as StatusType, bq as StatusView, by as sendOnRampFailedEvent } from './index-BCU32pT8.js';
-import { O as OnRampWidgetViews, T as TopUpView } from './TopUpView-CIYLtGDm.js';
-import { S as SpendingCapHero } from './SpendingCapHero-Cg4WWClJ.js';
+import { bI as global, $ as useAnalytics, r as reactExports, Z as ConnectLoaderContext, a1 as EventTargetContext, l as useTranslation, X as ViewContext, p as SharedViews, bJ as ExchangeType, j as jsx, ao as SimpleLayout, ak as HeaderNavigation, bK as sendOnRampWidgetCloseEvent, a7 as orchestrationEvents, I as IMTBLWidgetEvents, G as Box, a6 as UserJourney, V as ViewActions, an as FooterLogo, o as jsxs, aA as SimpleTextBody, aD as viewReducer, aE as initialViewState, bt as NATIVE, L as LoadingView, bL as sendOnRampSuccessEvent, b1 as StatusType, bE as StatusView, bM as sendOnRampFailedEvent } from './index-_4pTEm9m.js';
+import { O as OnRampWidgetViews, T as TopUpView } from './TopUpView-DrTM31Ek.js';
+import { S as SpendingCapHero } from './SpendingCapHero-B1bghRag.js';
 
 function isNull(arg) {
   return arg === null;