@getpara/react-sdk 0.1.0

package/dist/modal/stores/externalWalletProvider/useExternalWalletProviderStore.d.ts

@@ -0,0 +1,20 @@
+import { EvmExternalWalletContextType, EvmExternalWalletProvider } from '../../providers/EvmExternalWalletContextStub.js';
+import { Context } from 'react';
+import { SolanaExternalWalletContextType, SolanaExternalWalletProvider } from '../../providers/SolanaExternalWalletContextStub.js';
+import { CosmosExternalWalletContextType, CosmosExternalWalletProvider } from '../../providers/CosmosExternalWalletContextStub.js';
+interface ExternalWalletProviderState {
+    EvmProvider?: typeof EvmExternalWalletProvider;
+    evmContext?: Context<EvmExternalWalletContextType>;
+    SolanaProvider?: typeof SolanaExternalWalletProvider;
+    solanaContext?: Context<SolanaExternalWalletContextType>;
+    CosmosProvider?: typeof CosmosExternalWalletProvider;
+    cosmosContext?: Context<CosmosExternalWalletContextType>;
+    connectParaEvmWallet?: () => Promise<any>;
+    connectParaCosmosWallet?: () => Promise<any>;
+}
+export interface ExternalWalletProviderActions {
+    updateState: (state: Partial<ExternalWalletProviderState>) => void;
+}
+export type ExternalWalletProviderStore = ExternalWalletProviderState & ExternalWalletProviderActions;
+export declare const useExternalWalletProviderStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ExternalWalletProviderStore>>;
+export {};

package/dist/modal/stores/externalWalletProvider/useExternalWalletProviderStore.js

@@ -0,0 +1,13 @@
+import { create } from 'zustand';
+import { getActions } from './actions.js';
+const DEFAULT_EX_WALLET_PROVIDER_STATE = {
+    EvmProvider: undefined,
+    evmContext: undefined,
+    SolanaProvider: undefined,
+    solanaContext: undefined,
+    CosmosProvider: undefined,
+    cosmosContext: undefined,
+    connectParaEvmWallet: undefined,
+    connectParaCosmosWallet: undefined,
+};
+export const useExternalWalletProviderStore = create(set => (Object.assign(Object.assign({}, DEFAULT_EX_WALLET_PROVIDER_STATE), getActions(set))));

package/dist/modal/stores/index.d.ts

@@ -0,0 +1,4 @@
+export * from './modal/useModalStore.js';
+export * from './para/useParaStore.js';
+export * from './userInfo/useUserInfoStore.js';
+export * from './theme/useThemeStore.js';

package/dist/modal/stores/index.js

@@ -0,0 +1,4 @@
+export * from './modal/useModalStore.js';
+export * from './para/useParaStore.js';
+export * from './userInfo/useUserInfoStore.js';
+export * from './theme/useThemeStore.js';

package/dist/modal/stores/modal/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { ModalActions, ModalStore } from './useModalStore.js';
+export declare const getActions: (set: StoreApi<ModalStore>["setState"], get: StoreApi<ModalStore>["getState"]) => ModalActions;

package/dist/modal/stores/modal/actions.js

@@ -0,0 +1,65 @@
+import { DEFAULT_MODAL_STATE } from './useModalStore.js';
+import { AccountPreviousStep, LoginPreviousStep, ModalStep, SignUpPreviousStep } from '../../utils/steps.js';
+export const getActions = (set, get) => ({
+    resetState: () => set(DEFAULT_MODAL_STATE),
+    setOnModalStepChange: onModalStepChange => set({ onModalStepChange }),
+    setStep: step => {
+        const onModalStepChange = get().onModalStepChange;
+        const previousStep = get().step;
+        set({ step });
+        onModalStepChange === null || onModalStepChange === void 0 ? void 0 : onModalStepChange({ previousStep, currentStep: step, canGoBack: get().hasPreviousStep() });
+    },
+    decrementStep: () => {
+        const onModalStepChange = get().onModalStepChange;
+        const isLogin = get().flow === 'login';
+        const isAccount = get().flow === 'account';
+        const currentStep = get().step;
+        const webAuthURLForCreate = get().webAuthURLForCreate;
+        const iFrameUrl = get().iFrameUrl;
+        let prevStep = (isAccount ? AccountPreviousStep : isLogin ? LoginPreviousStep : SignUpPreviousStep)[currentStep];
+        if (currentStep === ModalStep.PASSWORD_CREATION && iFrameUrl && !webAuthURLForCreate) {
+            prevStep = ModalStep.AUTH_MAIN;
+        }
+        if (currentStep === ModalStep.EX_WALLET_SELECTED) {
+            set({ selectedExternalWalletId: undefined, isExternalWalletConnecting: false, externalWalletError: undefined });
+        }
+        if (prevStep) {
+            set({ step: prevStep, stepDirection: -1 });
+            onModalStepChange === null || onModalStepChange === void 0 ? void 0 : onModalStepChange({ previousStep: currentStep, currentStep: prevStep, canGoBack: get().hasPreviousStep() });
+        }
+    },
+    hasPreviousStep: () => {
+        const isLogin = get().flow === 'login';
+        const isAccount = get().flow === 'account';
+        const currentStep = get().step;
+        return !!(isAccount
+            ? AccountPreviousStep[currentStep]
+            : isLogin
+                ? LoginPreviousStep[currentStep]
+                : SignUpPreviousStep[currentStep]);
+    },
+    setPopupWindow: popupWindow => {
+        set({ popupWindow });
+    },
+    setFlow: flow => set({ flow }),
+    isLogin: () => get().flow === 'login',
+    isAccount: () => get().flow === 'account',
+    setWebAuthURLForLogin: url => set({ webAuthURLForLogin: url }),
+    setWebAuthURLForCreate: url => set({ webAuthURLForCreate: url }),
+    setPasswordUrlForLogin: url => set({ passwordUrlForLogin: url }),
+    setSupportedAuthMethods: supportedAuthMethods => set({ supportedAuthMethods }),
+    setOnRampPurchase: onRampPurchase => set(state => ({ onRampPurchase: Object.assign(Object.assign({}, (state.onRampPurchase || {})), onRampPurchase) })),
+    setOnRampConfig: onRampConfig => set({ onRampConfig }),
+    setIsFullyLoggedIn: isFullyLoggedIn => set({ isFullyLoggedIn }),
+    setAccountAddFundTab: accountAddFundTab => set({ accountAddFundTab }),
+    setSelectedExternalWalletId: selectedExternalWalletId => set({ selectedExternalWalletId }),
+    setIsExternalWalletConnecting: isExternalWalletConnecting => set({ isExternalWalletConnecting }),
+    setExternalWalletError: externalWalletError => set({ externalWalletError }),
+    setIsUsingMobileConnector: isUsingMobileConnector => set({ isUsingMobileConnector }),
+    setStepDirection: stepDirection => set({ stepDirection }),
+    setActiveWallet: activeWallet => set({ activeWallet }),
+    setFarcasterConnectUri: farcasterConnectUri => set({ farcasterConnectUri }),
+    setBiometricLocationHints: biometricLocationHints => set({ biometricLocationHints }),
+    setIFrameUrl: iFrameUrl => set({ iFrameUrl }),
+    setIsIFrameReady: isIFrameReady => set({ isIFrameReady }),
+});

package/dist/modal/stores/modal/useModalStore.d.ts

@@ -0,0 +1,82 @@
+import { ModalStep } from '../../utils/steps.js';
+import { OnRampConfig as OnRampConfigBase, OnRampPurchase, WalletType } from '@getpara/web-sdk';
+import { Tab as AddFundsTabType } from '../../components/AddFunds/AddFunds.js';
+import { AuthMethod } from '@getpara/core-sdk';
+import { BiometricLocationHint } from '@getpara/user-management-client';
+type Flow = 'login' | 'signUp' | 'account';
+type ActiveWallet = [string | undefined, WalletType | undefined];
+export type OnRampConfig = OnRampConfigBase & {
+    testMode?: boolean;
+};
+export interface OnModalStepChangeValue {
+    previousStep: ModalStep;
+    currentStep: ModalStep;
+    canGoBack: boolean;
+}
+interface ModalState {
+    step: ModalStep;
+    stepDirection: 1 | -1;
+    flow: Flow | undefined;
+    webAuthURLForLogin: string | undefined;
+    webAuthURLForCreate: string | undefined;
+    passwordUrlForLogin: string | undefined;
+    supportedAuthMethods: Set<AuthMethod>;
+    onModalStepChange: (value: OnModalStepChangeValue) => void | undefined;
+    onRampConfig: OnRampConfig | undefined;
+    onRampPurchase: Partial<OnRampPurchase> | undefined;
+    popupWindow: Window | undefined;
+    isFullyLoggedIn: boolean;
+    accountAddFundTab?: AddFundsTabType;
+    selectedExternalWalletId?: string;
+    isUsingMobileConnector?: boolean;
+    isExternalWalletConnecting?: boolean;
+    externalWalletError?: string[];
+    activeWallet: ActiveWallet | undefined;
+    farcasterConnectUri: string | undefined;
+    biometricLocationHints: BiometricLocationHint[] | undefined;
+    iFrameUrl: string | undefined;
+    isIFrameReady: boolean | undefined;
+}
+export interface ModalActions {
+    resetState: () => void;
+    setStep: (step: ModalStep) => void;
+    decrementStep: () => void;
+    hasPreviousStep: () => boolean;
+    setFlow: (flow?: Flow) => void;
+    isLogin: () => boolean;
+    isAccount: () => boolean;
+    setSupportedAuthMethods: (authMethods: Set<AuthMethod>) => void;
+    setWebAuthURLForLogin: (url?: string) => void;
+    setWebAuthURLForCreate: (url?: string) => void;
+    setPasswordUrlForLogin: (url?: string) => void;
+    setOnModalStepChange: (fn: (value: OnModalStepChangeValue) => void) => void;
+    setOnRampConfig: (_: OnRampConfig | undefined) => void;
+    setOnRampPurchase: (_: Partial<OnRampPurchase> | undefined) => void;
+    setPopupWindow: (_: Window | undefined) => void;
+    setIsFullyLoggedIn: (isFullyLoggedIn: boolean) => void;
+    setAccountAddFundTab: (accountAddFundTab: AddFundsTabType) => void;
+    setSelectedExternalWalletId: (id?: string) => void;
+    setIsUsingMobileConnector: (isUsingMobileConnector?: boolean) => void;
+    setIsExternalWalletConnecting: (isExternalWalletConnecting: boolean) => void;
+    setExternalWalletError: (externalWalletError?: string[]) => void;
+    setStepDirection: (stepDirection: 1 | -1) => void;
+    setActiveWallet: (_: ActiveWallet | undefined) => void;
+    setFarcasterConnectUri: (_: string | undefined) => void;
+    setBiometricLocationHints: (_?: BiometricLocationHint[]) => void;
+    setIFrameUrl: (_?: string) => void;
+    setIsIFrameReady: (_?: boolean) => void;
+}
+export type ModalStore = ModalState & ModalActions;
+export declare const DEFAULT_MODAL_STATE: Omit<ModalState, 'step' | 'onRampConfig'>;
+export declare const useModalStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ModalStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ModalStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ModalStore) => void) => () => void;
+        onFinishHydration: (fn: (state: ModalStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ModalStore, unknown>>;
+    };
+}>;
+export {};

package/dist/modal/stores/modal/useModalStore.js

@@ -0,0 +1,41 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { ModalStep } from '../../utils/steps.js';
+import { getActions } from './actions.js';
+// Omitting step from default here since it's set dynamically when the modal opens and closes
+export const DEFAULT_MODAL_STATE = {
+    flow: undefined,
+    stepDirection: 1,
+    webAuthURLForLogin: undefined,
+    webAuthURLForCreate: undefined,
+    passwordUrlForLogin: undefined,
+    supportedAuthMethods: new Set(),
+    onModalStepChange: undefined,
+    onRampPurchase: undefined,
+    popupWindow: undefined,
+    isFullyLoggedIn: false,
+    accountAddFundTab: undefined,
+    isExternalWalletConnecting: false,
+    externalWalletError: undefined,
+    activeWallet: [undefined, undefined],
+    farcasterConnectUri: undefined,
+    biometricLocationHints: undefined,
+    iFrameUrl: undefined,
+    isIFrameReady: undefined,
+};
+export const useModalStore = create()(persist((set, get) => (Object.assign(Object.assign({ step: ModalStep.AUTH_MAIN, onRampConfig: undefined, activeWallet: undefined }, DEFAULT_MODAL_STATE), getActions(set, get))), {
+    version: 1,
+    name: '@CAPSULE/modalState',
+    storage: createJSONStorage(() => sessionStorage),
+    partialize: state => ({
+        step: state.step,
+        webAuthURLForLogin: state.webAuthURLForLogin,
+        webAuthURLForCreate: state.webAuthURLForCreate,
+        passwordUrlForLogin: state.passwordUrlForLogin,
+        biometricLocationHints: state.biometricLocationHints,
+        onRampPurchase: state.onRampPurchase,
+        selectedExternalWalletId: state.selectedExternalWalletId,
+        isUsingMobileConnector: state.isUsingMobileConnector,
+        supportedAuthMethods: state.supportedAuthMethods,
+    }),
+}));

package/dist/modal/stores/para/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { ParaActions, ParaStore } from './useParaStore.js';
+export declare const getActions: (set: StoreApi<ParaStore>["setState"]) => ParaActions;

package/dist/modal/stores/para/actions.js

@@ -0,0 +1,5 @@
+export const getActions = (set) => ({
+    setPara: para => {
+        set({ para: para });
+    },
+});

package/dist/modal/stores/para/useParaStore.d.ts

@@ -0,0 +1,10 @@
+import { ParaInternal } from '@getpara/react-common';
+interface ParaState {
+    para: ParaInternal | undefined;
+}
+export interface ParaActions {
+    setPara: (para: ParaInternal) => void;
+}
+export type ParaStore = ParaState & ParaActions;
+export declare const useParaStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ParaStore>>;
+export {};

package/dist/modal/stores/para/useParaStore.js

@@ -0,0 +1,3 @@
+import { create } from 'zustand';
+import { getActions } from './actions.js';
+export const useParaStore = create(set => (Object.assign({ para: undefined }, getActions(set))));

package/dist/modal/stores/theme/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { ThemeActions, ThemeStore } from './useThemeStore.js';
+export declare const getActions: (set: StoreApi<ThemeStore>["setState"], get: StoreApi<ThemeStore>["getState"]) => ThemeActions;

package/dist/modal/stores/theme/actions.js

@@ -0,0 +1,24 @@
+export const getActions = (set, get) => ({
+    updateState: state => {
+        set(state);
+    },
+    getLogo: () => {
+        var _a;
+        return (_a = get().logo) !== null && _a !== void 0 ? _a : undefined;
+    },
+    setAuthLayout: authLayout => {
+        const types = [];
+        const uniqueLayouts = [];
+        authLayout.map(layout => {
+            const type = layout.split(':')[0];
+            if (!types.includes(type)) {
+                uniqueLayouts.push(layout);
+                types.push(type);
+            }
+            else {
+                console.warn(`${layout} is a duplicate ${type} layout type. Please remove the duplicate type from your config.`);
+            }
+        });
+        set({ authLayout: uniqueLayouts });
+    },
+});

package/dist/modal/stores/theme/useThemeStore.d.ts

@@ -0,0 +1,20 @@
+import { ParaModalTheme, OAuthLogoVariantType, TAuthLayout } from '../../types/modalProps.js';
+interface ThemeState {
+    isDark?: boolean;
+    logo?: string;
+    appName?: string;
+    bareModal?: boolean;
+    embeddedModal?: boolean;
+    oAuthLogoVariant?: OAuthLogoVariantType;
+    authLayout?: TAuthLayout[];
+    theme?: ParaModalTheme;
+    hideWallets?: boolean;
+}
+export interface ThemeActions {
+    updateState: (state: Partial<ThemeState>) => void;
+    getLogo: () => string | undefined;
+    setAuthLayout: (authLayout: TAuthLayout[]) => void;
+}
+export type ThemeStore = ThemeState & ThemeActions;
+export declare const useThemeStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ThemeStore>>;
+export {};

package/dist/modal/stores/theme/useThemeStore.js

@@ -0,0 +1,14 @@
+import { create } from 'zustand';
+import { getActions } from './actions.js';
+import { AuthLayout } from '../../types/modalProps.js';
+const DEFAULT_THEME = {
+    isDark: false,
+    logo: undefined,
+    appName: undefined,
+    bareModal: false,
+    embeddedModal: false,
+    oAuthLogoVariant: undefined,
+    authLayout: [AuthLayout.AUTH_FULL, AuthLayout.EXTERNAL_FULL],
+    hideWallets: false,
+};
+export const useThemeStore = create((set, get) => (Object.assign(Object.assign({}, DEFAULT_THEME), getActions(set, get))));

package/dist/modal/stores/userInfo/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { UserInfoActions, UserInfoStore } from './useUserInfoStore.js';
+export declare const getActions: (set: StoreApi<UserInfoStore>["setState"], get: StoreApi<UserInfoStore>["getState"]) => UserInfoActions;

package/dist/modal/stores/userInfo/actions.js

@@ -0,0 +1,28 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DEFAULT_USER_INFO_STATE } from './useUserInfoStore.js';
+import { extractAuthInfo } from '@getpara/user-management-client';
+export const getActions = (set, get) => ({
+    resetState: () => {
+        set(DEFAULT_USER_INFO_STATE);
+    },
+    setAuthInfo: (_a) => {
+        var { pfpUrl, displayName } = _a, auth = __rest(_a, ["pfpUrl", "displayName"]);
+        set({ auth, pfpUrl: pfpUrl || null, displayName: displayName || null });
+    },
+    getAuthInfo: () => {
+        return get().auth ? Object.assign(Object.assign({}, extractAuthInfo(get().auth)), { pfpUrl: get().pfpUrl, displayName: get().displayName }) : null;
+    },
+    setRecoveryShare: recoveryShare => {
+        set({ recoveryShare });
+    },
+});

package/dist/modal/stores/userInfo/useUserInfoStore.d.ts

@@ -0,0 +1,19 @@
+import { Auth } from '@getpara/user-management-client';
+import { ModalAuthInfo } from '@getpara/react-common';
+type SetAuthInfo = Auth & Partial<Pick<ModalAuthInfo, 'pfpUrl' | 'displayName'>>;
+type UserInfoState = {
+    auth: Auth | null;
+    pfpUrl: string | null;
+    displayName: string | null;
+    recoveryShare: string | null;
+};
+export interface UserInfoActions {
+    resetState: () => void;
+    setAuthInfo: (auth: SetAuthInfo) => void;
+    getAuthInfo: () => ModalAuthInfo | null;
+    setRecoveryShare: (recoveryShare: string | null) => void;
+}
+export type UserInfoStore = UserInfoState & UserInfoActions;
+export declare const DEFAULT_USER_INFO_STATE: UserInfoState;
+export declare const useUserInfoStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UserInfoStore>>;
+export {};

package/dist/modal/stores/userInfo/useUserInfoStore.js

@@ -0,0 +1,9 @@
+import { create } from 'zustand';
+import { getActions } from './actions.js';
+export const DEFAULT_USER_INFO_STATE = {
+    auth: null,
+    recoveryShare: null,
+    pfpUrl: null,
+    displayName: null,
+};
+export const useUserInfoStore = create((set, get) => (Object.assign(Object.assign({}, DEFAULT_USER_INFO_STATE), getActions(set, get))));

package/dist/modal/types/commonTypes.d.ts

@@ -0,0 +1,48 @@
+import { IconType } from '@getpara/react-components';
+export type WalletMetadata = {
+    id: string;
+    name: string;
+    iconUrl: string;
+    installed?: boolean;
+    isExtension?: boolean;
+    isMobile?: boolean;
+    isWeb?: boolean;
+    downloadUrl?: string;
+    getQrUri?: () => Promise<string>;
+    downloadUrls?: {
+        android?: string;
+        ios?: string;
+        mobile?: string;
+        qrCode?: string;
+        chrome?: string;
+        edge?: string;
+        firefox?: string;
+        opera?: string;
+        safari?: string;
+        browserExtension?: string;
+        macos?: string;
+        windows?: string;
+        linux?: string;
+        desktop?: string;
+    };
+};
+export type CommonWallet = {
+    connect: () => Promise<{
+        address?: string;
+        error?: string;
+    }>;
+    connectMobile: (isManualWalletConnect?: boolean) => Promise<{
+        address?: string;
+        error?: string;
+    }>;
+    type: 'EVM' | 'SOLANA' | 'COSMOS';
+} & WalletMetadata;
+export type CommonChain = {
+    id: string | number;
+    name: string;
+};
+export type Tab<T> = {
+    label: string;
+    value: T;
+    icon: IconType;
+};

package/dist/modal/types/commonTypes.js

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

package/dist/modal/types/externalWallets.d.ts

@@ -0,0 +1,31 @@
+export declare enum EvmWallet {
+    METAMASK = "METAMASK",
+    RAINBOW = "RAINBOW",
+    COINBASE = "COINBASE",
+    WALLETCONNECT = "WALLETCONNECT",
+    ZERION = "ZERION",
+    RABBY = "RABBY"
+}
+export declare enum SolanaWallet {
+    PHANTOM = "PHANTOM",
+    GLOW = "GLOW",
+    BACKPACK = "BACKPACK"
+}
+export declare enum CosmosWallet {
+    KEPLR = "KEPLR",
+    LEAP = "LEAP"
+}
+export declare const ExternalWallet: {
+    KEPLR: CosmosWallet.KEPLR;
+    LEAP: CosmosWallet.LEAP;
+    PHANTOM: SolanaWallet.PHANTOM;
+    GLOW: SolanaWallet.GLOW;
+    BACKPACK: SolanaWallet.BACKPACK;
+    METAMASK: EvmWallet.METAMASK;
+    RAINBOW: EvmWallet.RAINBOW;
+    COINBASE: EvmWallet.COINBASE;
+    WALLETCONNECT: EvmWallet.WALLETCONNECT;
+    ZERION: EvmWallet.ZERION;
+    RABBY: EvmWallet.RABBY;
+};
+export type TExternalWallet = keyof typeof ExternalWallet;

package/dist/modal/types/externalWallets.js

@@ -0,0 +1,21 @@
+export var EvmWallet;
+(function (EvmWallet) {
+    EvmWallet["METAMASK"] = "METAMASK";
+    EvmWallet["RAINBOW"] = "RAINBOW";
+    EvmWallet["COINBASE"] = "COINBASE";
+    EvmWallet["WALLETCONNECT"] = "WALLETCONNECT";
+    EvmWallet["ZERION"] = "ZERION";
+    EvmWallet["RABBY"] = "RABBY";
+})(EvmWallet || (EvmWallet = {}));
+export var SolanaWallet;
+(function (SolanaWallet) {
+    SolanaWallet["PHANTOM"] = "PHANTOM";
+    SolanaWallet["GLOW"] = "GLOW";
+    SolanaWallet["BACKPACK"] = "BACKPACK";
+})(SolanaWallet || (SolanaWallet = {}));
+export var CosmosWallet;
+(function (CosmosWallet) {
+    CosmosWallet["KEPLR"] = "KEPLR";
+    CosmosWallet["LEAP"] = "LEAP";
+})(CosmosWallet || (CosmosWallet = {}));
+export const ExternalWallet = Object.assign(Object.assign(Object.assign({}, EvmWallet), SolanaWallet), CosmosWallet);

package/dist/modal/types/modalProps.d.ts

@@ -0,0 +1,138 @@
+import ParaWeb, { CurrentWalletIds, OAuthMethod, deprecated__NetworkProp, deprecated__OnRampConfig } from '@getpara/web-sdk';
+import { Theme } from '@getpara/react-components';
+import { OnModalStepChangeValue } from '../stores/index.js';
+import { ModalStep, ModalStepProp } from '../utils/steps.js';
+import { TExternalWallet } from './externalWallets.js';
+export type ParaModalHandle = {
+    /**
+     * Move the modal backward
+     */
+    goBack: () => void;
+    /**
+     * Returns if the modal can go back
+     */
+    canGoBack: () => boolean;
+    /**
+     * Returns if the modal is expanded
+     */
+    currentStep: () => ModalStep;
+    /**
+     * Trigger the modal close handler
+     */
+    handleModalClose: () => void;
+};
+export type OAuthLogoVariantType = 'dark' | 'light' | 'default';
+export type ParaModalTheme = Theme & {
+    oAuthLogoVariant?: OAuthLogoVariantType;
+};
+export declare enum AuthLayout {
+    AUTH_FULL = "AUTH:FULL",
+    AUTH_CONDENSED = "AUTH:CONDENSED",
+    EXTERNAL_FULL = "EXTERNAL:FULL",
+    EXTERNAL_CONDENSED = "EXTERNAL:CONDENSED"
+}
+export type TAuthLayout = `${AuthLayout}`;
+export interface ParaModalProps {
+    /**
+     * Your ParaWeb instance.
+     */
+    para: ParaWeb;
+    /**
+     * Whether or not the modal is open.
+     */
+    isOpen: boolean;
+    /**
+     * Whether or not to show two-factor authentication steps to users.
+     * Defaults to `false`.
+     */
+    twoFactorAuthEnabled?: boolean;
+    /**
+     * Whether or not to show the wallet recovery to users.
+     * Defaults to `false`
+     */
+    recoverySecretStepEnabled?: boolean;
+    /**
+     * Which OAuth methods (if any) to show.
+     * Defaults to `true`.
+     */
+    oAuthMethods?: OAuthMethod[];
+    /**
+     * Whether or not to allow for email login. If true, only OAuth login will be available.
+     * Defaults to `false`.
+     */
+    disableEmailLogin?: boolean;
+    /**
+     * Whether or not to allow for phone login. If true, only OAuth login will be available.
+     * Defaults to `false`.
+     */
+    disablePhoneLogin?: boolean;
+    /**
+     * Theming to be used throughout the modal.
+     */
+    theme?: ParaModalTheme;
+    /**
+     * Logo to be shown throughout the modal.
+     */
+    logo?: string;
+    /**
+     * App name to be shown throughout the modal.
+     */
+    appName?: string;
+    /**
+     * Configure on-ramp providers to allow users to add funds upon signing up.
+     * @deprecated Configure on-ramps in the Para Developer Portal.
+     */
+    onRampConfig?: deprecated__OnRampConfig;
+    /**
+     * Configures which EVM networks your app supports, an array of one or more of `["ETHEREUM", "ARBITRUM", "BASE", "OPTIMISM", and "POLYGON"]`.
+     * Defaults to `["ETHEREUM"]`.
+     * @deprecated Configure this setting in the Para Developer Portal.
+     */
+    networks?: deprecated__NetworkProp[];
+    /**
+     * Whether or not to run configured on-ramp providers in test mode.
+     */
+    onRampTestMode?: boolean;
+    /**
+     * Whether to display information about on-chain wallets and use related terminology in the Para Modal.
+     */
+    hideWallets?: boolean;
+    currentStepOverride?: ModalStepProp | undefined;
+    /**
+     * Whether or not to display just the modal without the overlay component.
+     * Useful for rendering the modal inside a custom component
+     * Defaults to `false`
+     */
+    bareModal?: boolean;
+    /**
+     * Whether or not to use the embedded modal styling
+     * This is typically only used internally by Para and may result in unwanted styling!
+     */
+    embeddedModal?: boolean;
+    className?: string;
+    /**
+     * Which external wallets to show and in what order they should be displayed.
+     *
+     * NOTE: Any wallets that are detected as installed will be sorted first, followed by those that are not detected or not installed.
+     */
+    externalWallets?: TExternalWallet[];
+    /**
+     * How the modal should order the components on the main auth screen.
+     * Only the first method of each type (auth or external) will be used.
+     * Default to [AuthLayout.AUTH_FULL, AuthLayout.EXTERNAL_FULL]
+     */
+    authLayout?: TAuthLayout[];
+    /**
+     * Called when the modal step changes
+     */
+    onModalStepChange?: (value: OnModalStepChangeValue) => void;
+    /**
+     * Called when the modal is closed
+     */
+    onClose: () => void;
+    loginTransitionOverride?: (para: ParaWeb) => Promise<void>;
+    createWalletOverride?: (para: ParaWeb) => Promise<{
+        recoverySecret?: string;
+        walletIds: CurrentWalletIds;
+    }>;
+}

package/dist/modal/types/modalProps.js

@@ -0,0 +1,7 @@
+export var AuthLayout;
+(function (AuthLayout) {
+    AuthLayout["AUTH_FULL"] = "AUTH:FULL";
+    AuthLayout["AUTH_CONDENSED"] = "AUTH:CONDENSED";
+    AuthLayout["EXTERNAL_FULL"] = "EXTERNAL:FULL";
+    AuthLayout["EXTERNAL_CONDENSED"] = "EXTERNAL:CONDENSED";
+})(AuthLayout || (AuthLayout = {}));