@imtbl/checkout-widgets 2.0.0-alpha.0

package/dist/types/components/Transak/useTransakIframe.d.ts

@@ -0,0 +1,41 @@
+import { Environment } from '@imtbl/config';
+import { TransakNFTData } from './TransakTypes';
+export type TransakWidgetType = 'on-ramp' | 'nft-checkout';
+export type TransakNFTCheckoutParams = {
+    nftData: TransakNFTData[];
+    calldata: string;
+    cryptoCurrencyCode: string;
+    estimatedGasLimit: number;
+    exchangeScreenTitle: string;
+    walletAddress: string;
+    email: string;
+    partnerOrderId?: string;
+    excludeFiatCurrencies?: string[];
+};
+type UseTransakIframeProps = {
+    type: TransakWidgetType;
+    contractId: string;
+    environment: Environment;
+    transakParams: TransakNFTCheckoutParams;
+    onError?: () => void;
+};
+export declare const TRANSAK_WIDGET_BASE_URL: {
+    sandbox: string;
+    production: string;
+};
+export declare const TRANSAK_API_BASE_URL: {
+    sandbox: string;
+    production: string;
+};
+export declare const TRANSAK_ENVIRONMENT: {
+    sandbox: string;
+    production: string;
+};
+export declare const TRANSAK_API_KEY: {
+    sandbox: string;
+    production: string;
+};
+export declare const useTransakIframe: (props: UseTransakIframeProps) => {
+    iframeSrc: string;
+};
+export {};

package/dist/types/components/UnableToConnectDrawer/UnableToConnectDrawer.d.ts

@@ -0,0 +1,8 @@
+import { Checkout } from '@imtbl/checkout-sdk';
+export interface UnableToConnectDrawerProps {
+    visible: boolean;
+    checkout: Checkout;
+    onCloseDrawer: () => void;
+    onTryAgain?: () => void;
+}
+export declare function UnableToConnectDrawer({ visible, checkout, onCloseDrawer, onTryAgain, }: UnableToConnectDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/WalletDrawer/ConnectWalletDrawer.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { EIP6963ProviderDetail, EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { MenuItemProps } from '@biom3/react';
+import { ConnectEIP6963ProviderError } from '../../lib/connectEIP6963Provider';
+type ConnectWalletDrawerProps = {
+    heading: string;
+    visible: boolean;
+    onClose: (address?: string) => void;
+    onConnect?: (provider: WrappedBrowserProvider, providerInfo: EIP6963ProviderInfo) => void;
+    onError?: (errorType: ConnectEIP6963ProviderError) => void;
+    providerType: 'from' | 'to';
+    walletOptions: EIP6963ProviderDetail[];
+    bottomSlot?: ReactNode;
+    menuItemSize?: MenuItemProps['size'];
+    disabledOptions?: {
+        label: string;
+        rdns: string;
+    }[];
+    getShouldRequestWalletPermissions?: (providerInfo: EIP6963ProviderInfo) => boolean | undefined;
+    shouldIdentifyUser?: boolean;
+};
+export declare function ConnectWalletDrawer({ heading, visible, onClose, onConnect, onError, providerType, walletOptions, bottomSlot, menuItemSize, disabledOptions, getShouldRequestWalletPermissions, shouldIdentifyUser, }: ConnectWalletDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/WalletDrawer/DeliverToWalletDrawer.d.ts

@@ -0,0 +1,9 @@
+import { EIP6963ProviderDetail, EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+type DeliverToWalletDrawerProps = {
+    visible: boolean;
+    onClose: (toAddress?: string) => void;
+    walletOptions: EIP6963ProviderDetail[];
+    onConnect?: (providerType: 'from' | 'to', provider: WrappedBrowserProvider, providerInfo: EIP6963ProviderInfo) => void;
+};
+export declare function DeliverToWalletDrawer({ visible, onClose, onConnect, walletOptions, }: DeliverToWalletDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/WalletDrawer/PayWithWalletDrawer.d.ts

@@ -0,0 +1,12 @@
+import { EIP6963ProviderDetail, EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+type PayWithWalletDrawerProps = {
+    visible: boolean;
+    onClose: (fromAddress?: string) => void;
+    onConnect: (providerType: 'from' | 'to', provider: WrappedBrowserProvider, providerInfo: EIP6963ProviderInfo) => void;
+    onPayWithCard?: () => void;
+    walletOptions: EIP6963ProviderDetail[];
+    insufficientBalance?: boolean;
+    showOnRampOption?: boolean;
+};
+export declare function PayWithWalletDrawer({ visible, onClose, onConnect, onPayWithCard, walletOptions, insufficientBalance, showOnRampOption, }: PayWithWalletDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/WalletDrawer/WalletConnectItem.d.ts

@@ -0,0 +1,7 @@
+import { MenuItemProps } from '@biom3/react';
+export interface WalletConnectItemProps {
+    onWalletItemClick: () => Promise<void>;
+    loading: boolean;
+    size?: MenuItemProps['size'];
+}
+export declare const WalletConnectItem: import("react").ForwardRefExoticComponent<WalletConnectItemProps & import("react").RefAttributes<unknown>>;

package/dist/types/components/WalletDrawer/WalletDrawer.d.ts

@@ -0,0 +1,25 @@
+import { MenuItemProps } from '@biom3/react';
+import { ReactNode } from 'react';
+import { EIP6963ProviderDetail } from '@imtbl/checkout-sdk';
+import { WalletChangeEvent } from './WalletDrawerEvents';
+interface WalletDrawerProps {
+    testId: string;
+    drawerText: {
+        heading: string;
+        defaultText?: string;
+    };
+    showWalletConnect?: boolean;
+    showWalletSelectorTarget?: boolean;
+    walletOptions: EIP6963ProviderDetail[];
+    showDrawer: boolean;
+    setShowDrawer: (show: boolean) => void;
+    onWalletChange: (event: WalletChangeEvent) => Promise<void>;
+    menuItemSize?: MenuItemProps['size'];
+    bottomSlot?: ReactNode;
+    disabledOptions?: {
+        label: string;
+        rdns: string;
+    }[];
+}
+export declare function WalletDrawer({ testId, drawerText, walletOptions, showWalletConnect, showWalletSelectorTarget, showDrawer, setShowDrawer, onWalletChange, menuItemSize, bottomSlot, disabledOptions, }: WalletDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/WalletDrawer/WalletDrawerEvents.d.ts

@@ -0,0 +1,6 @@
+import { EIP1193Provider, EIP6963ProviderDetail } from '@imtbl/checkout-sdk';
+export type WalletChangeEvent = {
+    walletType: 'injected' | 'walletconnect';
+    provider: EIP1193Provider;
+    providerDetail: EIP6963ProviderDetail;
+};

package/dist/types/components/WalletDrawer/WalletDrawerStyles.d.ts

@@ -0,0 +1,7 @@
+export declare const walletItemListStyles: {
+    display: string;
+    flexDirection: string;
+    gap: string;
+    paddingX: string;
+    mb: string;
+};

package/dist/types/components/WalletDrawer/WalletItem.d.ts

@@ -0,0 +1,15 @@
+import { MenuItemProps } from '@biom3/react';
+import { ReactElement, ReactNode } from 'react';
+import { EIP6963ProviderInfo } from '@imtbl/checkout-sdk';
+export interface WalletItemProps<RC extends ReactElement | undefined = undefined> {
+    loading?: boolean;
+    recommended?: boolean;
+    testId: string;
+    providerInfo: EIP6963ProviderInfo;
+    onWalletItemClick: () => void;
+    rc?: RC;
+    size?: MenuItemProps['size'];
+    badge?: ReactNode;
+    disabled?: boolean;
+}
+export declare function WalletItem<RC extends ReactElement | undefined = undefined>({ rc, testId, loading, recommended, providerInfo, onWalletItemClick, size, badge, disabled, }: WalletItemProps<RC>): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/WithdrawalQueueDrawer/WithdrawalQueueDrawer.d.ts

@@ -0,0 +1,14 @@
+import { Checkout } from '@imtbl/checkout-sdk';
+export declare enum WithdrawalQueueWarningType {
+    TYPE_THRESHOLD = "exceedsThreshold",
+    TYPE_ACTIVE_QUEUE = "queueActivated"
+}
+export interface WithdrawalQueueDrawerProps {
+    visible: boolean;
+    checkout: Checkout;
+    onCloseDrawer: () => void;
+    warningType?: WithdrawalQueueWarningType;
+    onAdjustAmount?: () => void;
+    threshold?: number;
+}
+export declare function WithdrawalQueueDrawer({ visible, checkout, warningType, onCloseDrawer, onAdjustAmount, threshold, }: WithdrawalQueueDrawerProps): import("@emotion/react/jsx-runtime").JSX.Element | undefined;

package/dist/types/context/analytics-provider/CustomAnalyticsProvider.d.ts

@@ -0,0 +1,7 @@
+import { Checkout } from '@imtbl/checkout-sdk';
+type CustomAnalyticsProps = {
+    children: React.ReactNode;
+    checkout: Checkout;
+};
+export declare function CustomAnalyticsProvider({ children, checkout }: CustomAnalyticsProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/analytics-provider/SegmentAnalyticsProvider.d.ts

@@ -0,0 +1,42 @@
+import { StandardAnalyticsActions, StandardAnalyticsControlTypes } from '@imtbl/react-analytics';
+export declare enum UserJourney {
+    CONNECT = "Connect",
+    WALLET = "Wallet",
+    ON_RAMP = "OnRamp",
+    SWAP = "Swap",
+    BRIDGE = "Bridge",
+    SALE = "PrimarySale",
+    ADD_TOKENS = "AddTokens",
+    PURCHASE = "Purchase"
+}
+export type AnalyticsControlTypes = StandardAnalyticsControlTypes | 'IframeEvent' | 'Event';
+export declare const AnalyticsProvider: ({ children, loaderOverride: browserClass, log, }: import("react").PropsWithChildren<{
+    loaderOverride?: typeof import("@segment/analytics-next").AnalyticsBrowser;
+    log?: typeof console.debug;
+}>) => import("@emotion/react/jsx-runtime").JSX.Element, useAnalytics: () => {
+    page: (props: {
+        screen: string;
+        userJourney: UserJourney;
+        action?: StandardAnalyticsActions | undefined;
+        extras?: Record<string, unknown> | undefined;
+    }) => Promise<import("@segment/analytics-next").Context>;
+    track: (props: {
+        screen: string;
+        userJourney: UserJourney;
+        extras?: Record<string, unknown> | undefined;
+    } & ({
+        action: StandardAnalyticsActions;
+        control?: undefined;
+        controlType?: undefined;
+    } | {
+        control: string;
+        controlType: AnalyticsControlTypes;
+        action?: StandardAnalyticsActions | undefined;
+    })) => Promise<import("@segment/analytics-next").Context>;
+    identify: import("@segment/analytics-next/dist/types/core/buffer").AnalyticsBuffered["identify"];
+    group(traits: import("@segment/analytics-next").GroupTraits): Promise<import("@segment/analytics-next").Context>;
+    alias: import("@segment/analytics-next/dist/types/core/buffer").AnalyticsBuffered["alias"];
+    identifyFromCookie: () => Promise<import("@segment/analytics-next").Context>;
+    updateWriteKey: (writeKey: string) => void;
+    user: import("@segment/analytics-next/dist/types/core/buffer").AnalyticsBuffered["user"];
+};

package/dist/types/context/analytics-provider/SetupAnalytics.d.ts

@@ -0,0 +1,7 @@
+import { Checkout } from '@imtbl/checkout-sdk';
+type SetupAnalyticsProps = {
+    children: React.ReactNode;
+    checkout: Checkout;
+};
+export declare function SetupAnalytics({ children, checkout }: SetupAnalyticsProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/connect-loader-context/ConnectLoader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/context/connect-loader-context/ConnectLoaderContext.d.ts

@@ -0,0 +1,48 @@
+import { Checkout, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { ConnectWidgetViews } from '../view-context/ConnectViewContextTypes';
+export declare enum ConnectionStatus {
+    NOT_CONNECTED_NO_PROVIDER = "NOT_CONNECTED_NO_PROVIDER",
+    NOT_CONNECTED = "NOT_CONNECTED",
+    CONNECTED_WRONG_NETWORK = "CONNECTED_WRONG_NETWORK",
+    CONNECTED_WITH_NETWORK = "CONNECTED_WITH_NETWORK",
+    ERROR = "ERROR",
+    LOADING = "LOADING"
+}
+export interface ConnectLoaderState {
+    connectionStatus: ConnectionStatus;
+    deepLink?: ConnectWidgetViews;
+    checkout?: Checkout;
+    provider?: WrappedBrowserProvider;
+}
+export declare const initialConnectLoaderState: ConnectLoaderState;
+export interface ConnectLoaderContextState {
+    connectLoaderState: ConnectLoaderState;
+    connectLoaderDispatch: React.Dispatch<ConnectLoaderAction>;
+}
+export interface ConnectLoaderAction {
+    payload: ConnectLoaderActionPayload;
+}
+type ConnectLoaderActionPayload = UpdateConnectionStatusPayload | SetCheckoutPayload | SetProviderPayload;
+export declare enum ConnectLoaderActions {
+    UPDATE_CONNECTION_STATUS = "UPDATE_CONNECTION_STATUS",
+    SET_CHECKOUT = "SET_CHECKOUT",
+    SET_PROVIDER = "SET_PROVIDER"
+}
+export interface UpdateConnectionStatusPayload {
+    type: ConnectLoaderActions.UPDATE_CONNECTION_STATUS;
+    connectionStatus: ConnectionStatus;
+    deepLink?: ConnectWidgetViews;
+}
+export interface SetCheckoutPayload {
+    type: ConnectLoaderActions.SET_CHECKOUT;
+    checkout: Checkout;
+}
+export interface SetProviderPayload {
+    type: ConnectLoaderActions.SET_PROVIDER;
+    provider: WrappedBrowserProvider;
+}
+export declare const ConnectLoaderContext: import("react").Context<ConnectLoaderContextState>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export declare const connectLoaderReducer: Reducer<ConnectLoaderState, ConnectLoaderAction>;
+export declare const useConnectLoaderState: () => readonly [ConnectLoaderState, import("react").Dispatch<ConnectLoaderAction>];
+export {};

package/dist/types/context/connect-loader-context/test-components/ConnectLoaderTestComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ConnectLoaderState } from '../ConnectLoaderContext';
+export interface TestProps {
+    children: React.ReactNode;
+    initialStateOverride?: ConnectLoaderState;
+}
+export declare function ConnectLoaderTestComponent({ children, initialStateOverride }: TestProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/context/crypto-fiat-context/CryptoFiat.d.ts

@@ -0,0 +1,4 @@
+import { CryptoFiat, CryptoFiatConvertReturn } from '@imtbl/cryptofiat';
+import { FiatSymbols } from './CryptoFiatContext';
+export declare const updateConversions: (cryptoToFiatResult: CryptoFiatConvertReturn, fiatSymbol: FiatSymbols) => Map<string, number>;
+export declare const getCryptoToFiatConversion: (cryptoFiat: CryptoFiat, fiatSymbol: FiatSymbols, tokenSymbols: string[]) => Promise<Map<string, number>>;

package/dist/types/context/crypto-fiat-context/CryptoFiatContext.d.ts

@@ -0,0 +1,45 @@
+import { CryptoFiat } from '@imtbl/cryptofiat';
+export declare enum FiatSymbols {
+    USD = "usd"
+}
+export interface CryptoFiatState {
+    cryptoFiat: CryptoFiat | null;
+    fiatSymbol: FiatSymbols;
+    tokenSymbols: string[];
+    conversions: Map<string, number>;
+}
+export declare const initialCryptoFiatState: CryptoFiatState;
+export interface CryptoFiatContextState {
+    cryptoFiatState: CryptoFiatState;
+    cryptoFiatDispatch: React.Dispatch<CryptoFiatAction>;
+}
+export interface CryptoFiatAction {
+    payload: CryptoFiatActionPayload;
+}
+type CryptoFiatActionPayload = SetCryptoFiatPayload | SetFiatSymbolPayload | SetTokenSymbolsPayload | SetConversionsPayload;
+export declare enum CryptoFiatActions {
+    SET_CRYPTO_FIAT = "SET_CRYPTO_FIAT",
+    SET_FIAT_SYMBOL = "SET_FIAT_SYMBOL",
+    SET_TOKEN_SYMBOLS = "SET_TOKEN_SYMBOLS",
+    SET_CONVERSIONS = "SET_CONVERSIONS"
+}
+export interface SetCryptoFiatPayload {
+    type: CryptoFiatActions.SET_CRYPTO_FIAT;
+    cryptoFiat: CryptoFiat;
+}
+export interface SetFiatSymbolPayload {
+    type: CryptoFiatActions.SET_FIAT_SYMBOL;
+    fiatSymbol: FiatSymbols;
+}
+export interface SetTokenSymbolsPayload {
+    type: CryptoFiatActions.SET_TOKEN_SYMBOLS;
+    tokenSymbols: string[];
+}
+export interface SetConversionsPayload {
+    type: CryptoFiatActions.SET_CONVERSIONS;
+    conversions: Map<string, number>;
+}
+export declare const CryptoFiatContext: import("react").Context<CryptoFiatContextState>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export declare const cryptoFiatReducer: Reducer<CryptoFiatState, CryptoFiatAction>;
+export {};

package/dist/types/context/crypto-fiat-context/CryptoFiatContext.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/context/crypto-fiat-context/CryptoFiatProvider.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { Environment } from '@imtbl/config';
+interface CryptoFiatProviderProps {
+    environment: Environment;
+    children: ReactNode;
+}
+export declare const DEFAULT_TOKEN_SYMBOLS: string[];
+export declare function CryptoFiatProvider({ environment, children }: CryptoFiatProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/crypto-fiat-context/test-components/CryptoFiatTestComponent.d.ts

@@ -0,0 +1,5 @@
+interface CryptoFiatTestComponentProps {
+    tokenSymbols: string[];
+}
+export declare function CryptoFiatTestComponent({ tokenSymbols }: CryptoFiatTestComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/event-target-context/EventTarget.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/context/event-target-context/EventTargetContext.d.ts

@@ -0,0 +1,24 @@
+export interface EventTargetState {
+    eventTarget: Window | EventTarget;
+}
+export declare const initialEventTargetState: EventTargetState;
+export interface EventTargetContextState {
+    eventTargetState: EventTargetState;
+    eventTargetDispatch: React.Dispatch<EventTargetAction>;
+}
+export interface EventTargetAction {
+    payload: EventTargetActionPayload;
+}
+type EventTargetActionPayload = SetEventTargetPayload;
+export declare enum EventTargetActions {
+    SET_EVENT_TARGET = "SET_EVENT_TARGET"
+}
+export interface SetEventTargetPayload {
+    type: EventTargetActions.SET_EVENT_TARGET;
+    eventTarget: Window | EventTarget;
+}
+export declare const EventTargetContext: import("react").Context<EventTargetContextState>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export declare const eventTargetReducer: Reducer<EventTargetState, EventTargetAction>;
+export declare const useEventTargetState: () => readonly [EventTargetState, import("react").Dispatch<EventTargetAction>];
+export {};

package/dist/types/context/event-target-context/test-components/EventTargetTestComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { EventTargetState } from '../EventTargetContext';
+export interface TestProps {
+    children: React.ReactNode;
+    initialStateOverride?: EventTargetState;
+}
+export declare function EventTargetTestComponent({ children, initialStateOverride }: TestProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/context/handover-context/HandoverContext.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+export declare enum HandoverTarget {
+    GLOBAL = "global",
+    DRAWER = "drawer",
+    LOADER = "loader"
+}
+export type HandoverContent = {
+    children?: React.ReactNode;
+    animationUrl?: string;
+    inputValue?: number;
+    duration?: number;
+    onClose?: () => void;
+};
+export type HandoverLoader = {
+    text: string | string[];
+    duration?: number;
+};
+export type HandoverContextProps = {
+    loader: HandoverLoader | null;
+    isLoading: boolean;
+    showLoader: (loader: HandoverLoader) => void;
+    hideLoader: () => void;
+    handovers: {
+        [id: string]: HandoverContent;
+    };
+    addHandover: (handoverContent: HandoverContent, handoverTarget?: HandoverTarget) => void;
+    closeHandover: (handoverTarget?: HandoverTarget) => void;
+};
+export declare const HandoverContext: React.Context<HandoverContextProps>;

package/dist/types/context/handover-context/HandoverProvider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface HandoverProviderProps {
+    children: React.ReactNode;
+}
+export declare enum HandoverDuration {
+    SHORT = 1000,// in milliseconds
+    MEDIUM = 2000,
+    LONG = 3000
+}
+export declare function HandoverProvider({ children }: HandoverProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/providers-context/ProvidersContext.d.ts

@@ -0,0 +1,59 @@
+import { Checkout, EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+export interface ProvidersState {
+    fromProvider?: WrappedBrowserProvider;
+    fromProviderInfo?: EIP6963ProviderInfo;
+    fromAddress?: string;
+    toProvider?: WrappedBrowserProvider;
+    toProviderInfo?: EIP6963ProviderInfo;
+    toAddress?: string;
+    checkout: Checkout;
+    lockedToProvider?: boolean;
+}
+export declare const initialProvidersState: ProvidersState;
+export interface ProvidersContextState {
+    providersState: ProvidersState;
+    providersDispatch: React.Dispatch<ProvidersContextAction>;
+}
+export interface ProvidersContextAction {
+    payload: ProvidersContextActionPayload;
+}
+type ProvidersContextActionPayload = SetProviderPayload | SetCheckoutPayload | ResetStatePayload | SetLockedToProviderPayload;
+export declare enum ProvidersContextActions {
+    SET_PROVIDER = "SET_PROVIDER",
+    SET_CHECKOUT = "SET_CHECKOUT",
+    RESET_STATE = "RESET_STATE",
+    SET_LOCKED_TO_PROVIDER = "SET_LOCKED_TO_PROVIDER"
+}
+export interface SetProviderPayload {
+    type: ProvidersContextActions.SET_PROVIDER;
+    fromProvider?: WrappedBrowserProvider;
+    fromProviderInfo?: EIP6963ProviderInfo;
+    fromAddress?: string;
+    toProvider?: WrappedBrowserProvider;
+    toProviderInfo?: EIP6963ProviderInfo;
+    toAddress?: string;
+}
+export interface SetCheckoutPayload {
+    type: ProvidersContextActions.SET_CHECKOUT;
+    checkout: Checkout;
+}
+export interface ResetStatePayload {
+    type: ProvidersContextActions.RESET_STATE;
+    fromProvider?: WrappedBrowserProvider;
+    toProvider?: WrappedBrowserProvider;
+    checkout: Checkout;
+}
+export interface SetLockedToProviderPayload {
+    type: ProvidersContextActions.SET_LOCKED_TO_PROVIDER;
+    lockedToProvider: boolean;
+}
+export declare const ProvidersContext: import("react").Context<ProvidersContextState>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export declare const providersContextReducer: Reducer<ProvidersState, ProvidersContextAction>;
+export declare const useProvidersReducer: (initialState?: ProvidersState) => readonly [ProvidersState, import("react").Dispatch<ProvidersContextAction>];
+export declare function ProvidersContextProvider({ children, initialState, }: {
+    children: React.ReactNode;
+    initialState: ProvidersState;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const useProvidersContext: () => ProvidersContextState;
+export {};

package/dist/types/context/view-context/AddTokensViewContextTypes.d.ts

@@ -0,0 +1,29 @@
+import { TokenBalance } from '@0xsquid/sdk/dist/types';
+import { ViewType } from './ViewType';
+export declare enum AddTokensWidgetViews {
+    ADD_TOKENS = "ADD_TOKENS",
+    REVIEW = "REVIEW",
+    GEO_BLOCK_ERROR = "GEO_BLOCK_ERROR"
+}
+export type AddTokensWidgetView = AddTokensView | AddTokensReview | GeoBlockErrorView;
+interface AddTokensView extends ViewType {
+    type: AddTokensWidgetViews.ADD_TOKENS;
+}
+interface AddTokensReview extends ViewType {
+    type: AddTokensWidgetViews.REVIEW;
+    data: AddTokensReviewData;
+}
+interface GeoBlockErrorView extends ViewType {
+    type: AddTokensWidgetViews.GEO_BLOCK_ERROR;
+}
+export interface AddTokensReviewData {
+    balance: TokenBalance;
+    toAmount: string;
+    toChainId: string;
+    toTokenAddress: string;
+    additionalBuffer: number;
+}
+export interface AddTokensConfirmationData {
+    transactionHash: string;
+}
+export {};

package/dist/types/context/view-context/BridgeViewContextTypes.d.ts

@@ -0,0 +1,66 @@
+import { ApproveBridgeResponse, BridgeTxResponse } from '@imtbl/bridge-sdk';
+import { TransactionResponse } from 'ethers';
+import { Transaction } from '../../lib/clients';
+import { ViewType } from './ViewType';
+export declare enum BridgeWidgetViews {
+    WALLET_NETWORK_SELECTION = "WALLET_NETWORK_SELECTION",
+    BRIDGE_FORM = "BRIDGE_FORM",
+    BRIDGE_REVIEW = "BRIDGE_REVIEW",
+    IN_PROGRESS = "IN_PROGRESS",
+    BRIDGE_FAILURE = "BRIDGE_FAILURE",
+    APPROVE_TRANSACTION = "APPROVE_TRANSACTION",
+    TRANSACTIONS = "TRANSACTIONS",
+    CLAIM_WITHDRAWAL = "CLAIM_WITHDRAWAL",
+    CLAIM_WITHDRAWAL_IN_PROGRESS = "CLAIM_WITHDRAWAL_IN_PROGRESS",
+    CLAIM_WITHDRAWAL_SUCCESS = "CLAIM_WITHDRAWAL_SUCCESS",
+    CLAIM_WITHDRAWAL_FAILURE = "CLAIM_WITHDRAWAL_FAILURE",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
+}
+export type BridgeWidgetView = BridgeCrossWalletSelection | BridgeForm | BridgeReview | BridgeInProgress | BridgeFailure | BridgeApproveTransaction | BridgeTransactions | BridgeClaimWithdrawal | BridgeClaimWithdrawalInProgress | BridgeClaimWithdrawalSuccess | BridgeClaimWithdrawalFailure | BridgeServiceUnavailableView;
+interface BridgeCrossWalletSelection extends ViewType {
+    type: BridgeWidgetViews.WALLET_NETWORK_SELECTION;
+}
+interface BridgeForm extends ViewType {
+    type: BridgeWidgetViews.BRIDGE_FORM;
+}
+interface BridgeReview extends ViewType {
+    type: BridgeWidgetViews.BRIDGE_REVIEW;
+}
+interface BridgeInProgress extends ViewType {
+    type: BridgeWidgetViews.IN_PROGRESS;
+    transactionHash: string;
+    isTransfer: boolean;
+}
+interface BridgeFailure extends ViewType {
+    type: BridgeWidgetViews.BRIDGE_FAILURE;
+    reason: string;
+}
+interface BridgeApproveTransaction extends ViewType {
+    type: BridgeWidgetViews.APPROVE_TRANSACTION;
+    approveTransaction: ApproveBridgeResponse | undefined;
+    transaction: BridgeTxResponse | undefined;
+}
+interface BridgeTransactions extends ViewType {
+    type: BridgeWidgetViews.TRANSACTIONS;
+}
+interface BridgeClaimWithdrawal extends ViewType {
+    type: BridgeWidgetViews.CLAIM_WITHDRAWAL;
+    transaction: Transaction;
+}
+interface BridgeClaimWithdrawalInProgress extends ViewType {
+    type: BridgeWidgetViews.CLAIM_WITHDRAWAL_IN_PROGRESS;
+    transactionResponse: TransactionResponse;
+}
+export interface BridgeClaimWithdrawalSuccess extends ViewType {
+    type: BridgeWidgetViews.CLAIM_WITHDRAWAL_SUCCESS;
+    transactionHash: string;
+}
+export interface BridgeClaimWithdrawalFailure extends ViewType {
+    type: BridgeWidgetViews.CLAIM_WITHDRAWAL_FAILURE;
+    transactionHash: string;
+    reason: string;
+}
+export interface BridgeServiceUnavailableView extends ViewType {
+    type: BridgeWidgetViews.SERVICE_UNAVAILABLE;
+}
+export {};