@getpara/react-sdk-lite 2.0.0-alpha.33

package/dist/provider/stores/getters.d.ts

@@ -0,0 +1,4 @@
+export declare const getClient: () => import("@getpara/web-sdk").ParaWeb | undefined;
+export declare const getIsOpen: () => boolean;
+export declare const getSelectedWalletId: () => string | undefined;
+export declare const getSelectedWalletType: () => "EVM" | "SOLANA" | "COSMOS" | undefined;

package/dist/provider/stores/getters.js

@@ -0,0 +1,13 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { vanillaStore } from "./useStore.js";
+const getClient = () => vanillaStore.getState().client;
+const getIsOpen = () => vanillaStore.getState().isOpen;
+const getSelectedWalletId = () => vanillaStore.getState().selectedWalletId;
+const getSelectedWalletType = () => vanillaStore.getState().selectedWalletType;
+export {
+  getClient,
+  getIsOpen,
+  getSelectedWalletId,
+  getSelectedWalletType
+};

package/dist/provider/stores/setters.d.ts

@@ -0,0 +1 @@
+export declare const setIsOpen: (isOpen: boolean) => void;

package/dist/provider/stores/setters.js

@@ -0,0 +1,7 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { vanillaStore } from "./useStore.js";
+const setIsOpen = (isOpen) => vanillaStore.setState({ isOpen });
+export {
+  setIsOpen
+};

package/dist/provider/stores/slices/analytics.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { AnalyticsSlice, Store } from '../types.js';
+export declare const createAnalyticsSlice: StateCreator<Store, [], [], AnalyticsSlice>;

package/dist/provider/stores/slices/analytics.js

@@ -0,0 +1,9 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createAnalyticsSlice = (set) => ({
+  providerProps: {},
+  setProviderProps: (providerProps) => set({ providerProps })
+});
+export {
+  createAnalyticsSlice
+};

package/dist/provider/stores/slices/client.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { ClientSlice, Store } from '../types.js';
+export declare const createClientSlice: StateCreator<Store, [], [], ClientSlice>;

package/dist/provider/stores/slices/client.js

@@ -0,0 +1,9 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createClientSlice = (set) => ({
+  client: void 0,
+  setClient: (client) => set({ client })
+});
+export {
+  createClientSlice
+};

package/dist/provider/stores/slices/config.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { ConfigSlice, Store } from '../types.js';
+export declare const createConfigSlice: StateCreator<Store, [], [], ConfigSlice>;

package/dist/provider/stores/slices/config.js

@@ -0,0 +1,11 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createConfigSlice = (set) => ({
+  appName: "",
+  setAppName: (appName) => set({ appName }),
+  farcasterMiniAppConfig: void 0,
+  setFarcasterMiniAppConfig: (farcasterMiniAppConfig) => set({ farcasterMiniAppConfig })
+});
+export {
+  createConfigSlice
+};

package/dist/provider/stores/slices/externalWallets.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { ExternalWalletsSlice, Store } from '../types.js';
+export declare const createExternalWalletsSlice: StateCreator<Store, [], [], ExternalWalletsSlice>;

package/dist/provider/stores/slices/externalWallets.js

@@ -0,0 +1,46 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { EvmExternalWalletContext } from "../../external/stubs/EvmExternalWalletContextStub.js";
+import { CosmosExternalWalletContext } from "../../external/stubs/CosmosExternalWalletContextStub.js";
+import { SolanaExternalWalletContext } from "../../external/stubs/SolanaExternalWalletContextStub.js";
+import { createRef } from "react";
+const createExternalWalletsSlice = (set) => ({
+  externalWallets: [],
+  setExternalWallets: (externalWallets) => set({ externalWallets }),
+  externalWalletsWithFullAuth: [],
+  setExternalWalletsWithFullAuth: (externalWalletsWithFullAuth) => set({ externalWalletsWithFullAuth }),
+  includeWalletVerification: false,
+  setIncludeWalletVerification: (includeWalletVerification) => set({ includeWalletVerification }),
+  connectionOnly: false,
+  setConnectionOnly: (connectionOnly) => set({ connectionOnly }),
+  evmContext: EvmExternalWalletContext,
+  setEvmContext: (evmContext) => set({ evmContext }),
+  evmLib: void 0,
+  setEvmLib: (evmLib) => set({ evmLib }),
+  EvmProvider: void 0,
+  setEvmProvider: (EvmProvider) => set({ EvmProvider }),
+  evmWallets: [],
+  setEvmWallets: (evmWallets) => set({ evmWallets }),
+  isLoadingEvmLib: true,
+  setIsLoadingEvmLib: (isLoadingEvmLib) => set({ isLoadingEvmLib }),
+  cosmosContext: CosmosExternalWalletContext,
+  setCosmosContext: (cosmosContext) => set({ cosmosContext }),
+  CosmosProvider: void 0,
+  setCosmosProvider: (CosmosProvider) => set({ CosmosProvider }),
+  cosmosWallets: [],
+  setCosmosWallets: (cosmosWallets) => set({ cosmosWallets }),
+  isLoadingCosmosLib: true,
+  setIsLoadingCosmosLib: (isLoadingCosmosLib) => set({ isLoadingCosmosLib }),
+  solanaContext: SolanaExternalWalletContext,
+  setSolanaContext: (solanaContext) => set({ solanaContext }),
+  SolanaProvider: void 0,
+  setSolanaProvider: (SolanaProvider) => set({ SolanaProvider }),
+  solanaWallets: [],
+  setSolanaWallets: (solanaWallets) => set({ solanaWallets }),
+  isLoadingSolanaLib: true,
+  setIsLoadingSolanaLib: (isLoadingSolanaLib) => set({ isLoadingSolanaLib }),
+  onLoginRef: createRef()
+});
+export {
+  createExternalWalletsSlice
+};

package/dist/provider/stores/slices/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './modal.js';
+export * from './wallet.js';
+export * from './externalWallets.js';
+export * from './analytics.js';

package/dist/provider/stores/slices/index.js

@@ -0,0 +1,6 @@
+"use client";
+export * from "./client.js";
+export * from "./modal.js";
+export * from "./wallet.js";
+export * from "./externalWallets.js";
+export * from "./analytics.js";

package/dist/provider/stores/slices/modal.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { ModalSlice, Store } from '../types.js';
+export declare const createModalSlice: StateCreator<Store, [], [], ModalSlice>;

package/dist/provider/stores/slices/modal.js

@@ -0,0 +1,18 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { createRef } from "react";
+const createModalSlice = (set, get) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  return {
+    modalConfig: void 0,
+    setModalConfig: (modalConfig) => set({ modalConfig }),
+    isDarkTheme: ((_c = (_b = (_a = get()) == null ? void 0 : _a.modalConfig) == null ? void 0 : _b.theme) == null ? void 0 : _c.mode) === "dark",
+    oAuthLogoVariant: (_g = (_f = (_e = (_d = get()) == null ? void 0 : _d.modalConfig) == null ? void 0 : _e.theme) == null ? void 0 : _f.oAuthLogoVariant) != null ? _g : "default",
+    isOpen: false,
+    setIsOpen: (isOpen) => set({ isOpen }),
+    openedToStep: createRef()
+  };
+};
+export {
+  createModalSlice
+};

package/dist/provider/stores/slices/wallet.d.ts

@@ -0,0 +1,3 @@
+import { StateCreator } from 'zustand';
+import { Store, WalletSlice } from '../types.js';
+export declare const createWalletSlice: StateCreator<Store, [], [], WalletSlice>;

package/dist/provider/stores/slices/wallet.js

@@ -0,0 +1,13 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createWalletSlice = (set) => ({
+  rpcUrl: void 0,
+  setRpcUrl: (rpcUrl) => set({ rpcUrl }),
+  selectedWalletId: void 0,
+  selectedWalletType: void 0,
+  setSelectedWallet: (selectedWalletId, selectedWalletType) => set({ selectedWalletId, selectedWalletType }),
+  clearSelectedWallet: () => set({ selectedWalletId: void 0, selectedWalletType: void 0 })
+});
+export {
+  createWalletSlice
+};

package/dist/provider/stores/types.d.ts

@@ -0,0 +1,86 @@
+import { Context, MutableRefObject } from 'react';
+import ParaWeb, { TWalletType } from '@getpara/web-sdk';
+import * as paraEvmLib from '@getpara/evm-wallet-connectors';
+import { EvmExternalWalletContextType, ParaEvmProvider, WalletList as EvmWalletList } from '@getpara/evm-wallet-connectors';
+import { CosmosExternalWalletContextType, ParaCosmosProvider, WalletList as CosmosWalletList } from '@getpara/cosmos-wallet-connectors';
+import { ParaSolanaProvider, SolanaExternalWalletContextType, WalletList as SolanaWalletList } from '@getpara/solana-wallet-connectors';
+import { ModalStep, ParaModalProps } from '../../modal/index.js';
+import { OAuthLogoVariantType } from '../../modal/types/modalProps.js';
+import { type TExternalWallet } from '@getpara/react-common';
+export type FarcasterMiniAppConfig = {
+    /**
+     * Whether to disable automatic sign-in via the Farcaster user's existing miniapp wallet(s).
+     *
+     * If disabled, the Para Modal's will open to its normal sign-in screen, along with a "Continue with Farcaster" button allowing them to connect their mini-app wallets.
+     */
+    disableAutoConnect?: boolean;
+};
+export interface ClientSlice {
+    client?: ParaWeb;
+    setClient: (_: ParaWeb) => void;
+}
+export interface ConfigSlice {
+    appName: string;
+    setAppName: (_: string) => void;
+    farcasterMiniAppConfig?: FarcasterMiniAppConfig;
+    setFarcasterMiniAppConfig: (_?: FarcasterMiniAppConfig) => void;
+}
+export interface AnalyticsSlice {
+    providerProps: object;
+    setProviderProps: (_: object) => void;
+}
+export interface ModalSlice {
+    modalConfig?: ParaModalProps;
+    setModalConfig: (_?: ParaModalProps) => void;
+    isDarkTheme: boolean;
+    oAuthLogoVariant: OAuthLogoVariantType;
+    isOpen: boolean;
+    setIsOpen: (_: boolean) => void;
+    openedToStep: MutableRefObject<ModalStep | null>;
+}
+export interface WalletSlice {
+    rpcUrl?: string;
+    setRpcUrl: (_?: string) => void;
+    selectedWalletId?: string;
+    selectedWalletType?: TWalletType;
+    setSelectedWallet: (_?: string, __?: TWalletType) => void;
+    clearSelectedWallet: () => void;
+}
+export interface ExternalWalletsSlice {
+    externalWallets: TExternalWallet[];
+    setExternalWallets: (_: TExternalWallet[]) => void;
+    connectionOnly: boolean;
+    setConnectionOnly: (_: boolean) => void;
+    includeWalletVerification: boolean;
+    setIncludeWalletVerification: (_: boolean) => void;
+    externalWalletsWithFullAuth: TExternalWallet[];
+    setExternalWalletsWithFullAuth: (_: TExternalWallet[]) => void;
+    evmLib: typeof paraEvmLib | undefined;
+    setEvmLib: (_: typeof paraEvmLib) => void;
+    evmContext: Context<EvmExternalWalletContextType>;
+    setEvmContext: (_: Context<EvmExternalWalletContextType>) => void;
+    EvmProvider?: typeof ParaEvmProvider;
+    setEvmProvider: (_: typeof ParaEvmProvider) => void;
+    evmWallets: EvmWalletList;
+    setEvmWallets: (_: EvmWalletList) => void;
+    isLoadingEvmLib: boolean;
+    setIsLoadingEvmLib: (_: boolean) => void;
+    cosmosContext: Context<CosmosExternalWalletContextType>;
+    setCosmosContext: (_: Context<CosmosExternalWalletContextType>) => void;
+    CosmosProvider?: typeof ParaCosmosProvider;
+    setCosmosProvider: (_: typeof ParaCosmosProvider) => void;
+    cosmosWallets: CosmosWalletList;
+    setCosmosWallets: (_: CosmosWalletList) => void;
+    isLoadingCosmosLib: boolean;
+    setIsLoadingCosmosLib: (_: boolean) => void;
+    solanaContext: Context<SolanaExternalWalletContextType>;
+    setSolanaContext: (_: Context<SolanaExternalWalletContextType>) => void;
+    SolanaProvider?: typeof ParaSolanaProvider;
+    setSolanaProvider: (_: typeof ParaSolanaProvider) => void;
+    solanaWallets: SolanaWalletList;
+    setSolanaWallets: (_: SolanaWalletList) => void;
+    isLoadingSolanaLib: boolean;
+    setIsLoadingSolanaLib: (_: boolean) => void;
+    onLoginRef: MutableRefObject<(() => Promise<void>) | null>;
+}
+export type Store = ClientSlice & ModalSlice & WalletSlice & ExternalWalletsSlice & ConfigSlice & AnalyticsSlice;

package/dist/provider/stores/types.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/stores/useStore.d.ts

@@ -0,0 +1,17 @@
+import { StoreApi } from 'zustand';
+import { Store } from './types.js';
+export declare const vanillaStore: Omit<StoreApi<Store>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<Store, Pick<Store, "selectedWalletId" | "selectedWalletType">>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: Store) => void) => () => void;
+        onFinishHydration: (fn: (state: Store) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<Store, Pick<Store, "selectedWalletId" | "selectedWalletType">>>;
+    };
+};
+export declare const useStore: {
+    (): Store;
+    <T>(selector: (state: Store) => T): T;
+};

package/dist/provider/stores/useStore.js

@@ -0,0 +1,34 @@
+"use client";
+import {
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { createStore, useStore as useZustandStore } from "zustand";
+import {
+  createAnalyticsSlice,
+  createClientSlice,
+  createExternalWalletsSlice,
+  createModalSlice,
+  createWalletSlice
+} from "./slices/index.js";
+import { createJSONStorage, persist } from "zustand/middleware";
+import { createConfigSlice } from "./slices/config.js";
+const vanillaStore = createStore()(
+  persist(
+    (...a) => __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, createClientSlice(...a)), createModalSlice(...a)), createWalletSlice(...a)), createExternalWalletsSlice(...a)), createConfigSlice(...a)), createAnalyticsSlice(...a)),
+    {
+      version: 1,
+      name: "@PARA/provider-state",
+      storage: createJSONStorage(() => localStorage),
+      partialize: (state) => ({
+        selectedWalletId: state.selectedWalletId,
+        selectedWalletType: state.selectedWalletType
+      })
+    }
+  )
+);
+const createBoundedUseStore = (store) => (selector) => useZustandStore(store, selector);
+const useStore = createBoundedUseStore(vanillaStore);
+export {
+  useStore,
+  vanillaStore
+};

package/dist/provider/types/externalWalletProviders.d.ts

@@ -0,0 +1,12 @@
+import { ParaCosmosProviderConfig } from '@getpara/cosmos-wallet-connectors';
+import { ParaSolanaProviderConfig } from '@getpara/solana-wallet-connectors';
+import { Chain, Transport } from 'viem';
+import { type ParaEvmProviderConfig } from '@getpara/evm-wallet-connectors';
+import { type TExternalWallet } from '@getpara/react-common';
+export type ExternalWalletProviderCommon = {
+    isUsing: boolean;
+    wallets: TExternalWallet[];
+};
+export type ParaEvmProviderConfigNoWallets<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> = Omit<ParaEvmProviderConfig<chains, transports>, 'wallets'>;
+export type ParaCosmosProviderConfigNoWallets = Omit<ParaCosmosProviderConfig, 'wallets'>;
+export type ParaSolanaProviderConfigNoWallets = Omit<ParaSolanaProviderConfig, 'wallets'>;

package/dist/provider/types/externalWalletProviders.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/types/provider.d.ts

@@ -0,0 +1,166 @@
+import { ParaWagmiProviderProps } from '@getpara/evm-wallet-connectors';
+import ParaWeb, { AccountCreationEvent, AccountSetupEvent, ConstructorOpts, Environment, ExternalWalletChangeEvent, LoginEvent, LogoutEvent, PregenWalletClaimedEvent, SignMessageEvent, SignTransactionEvent, WalletCreatedEvent, WalletsChangeEvent, GuestWalletsCreatedEvent } from '@getpara/web-sdk';
+import { PropsWithChildren } from 'react';
+import { Chain, Transport } from 'viem';
+import { ParaModalProps } from '../../modal/index.js';
+import { ParaGrazProviderProps } from '@getpara/cosmos-wallet-connectors';
+import { ParaCosmosProviderConfigNoWallets, ParaEvmProviderConfigNoWallets, ParaSolanaProviderConfigNoWallets } from './externalWalletProviders.js';
+import { type TExternalWallet } from '@getpara/react-common';
+import { FarcasterMiniAppConfig } from '../stores/types.js';
+export type Callbacks = {
+    onLogout?: (event: LogoutEvent) => void;
+    onLogin?: (event: LoginEvent) => void;
+    onAccountSetup?: (event: AccountSetupEvent) => void;
+    onAccountCreation?: (event: AccountCreationEvent) => void;
+    onSignMessage?: (event: SignMessageEvent) => void;
+    onSignTransaction?: (event: SignTransactionEvent) => void;
+    onExternalWalletChange?: (event: ExternalWalletChangeEvent) => void;
+    onWalletsChange?: (event: WalletsChangeEvent) => void;
+    onWalletCreated?: (event: WalletCreatedEvent) => void;
+    onPregenWalletClaimed?: (event: PregenWalletClaimedEvent) => void;
+    onGuestWalletsCreated?: (event: GuestWalletsCreatedEvent) => void;
+};
+export type ParaProviderConfig = {
+    /**
+     * The name of your app, used throughout the modal and any configured external wallets.
+     */
+    appName: string;
+    /**
+     * Disables the automatic session keep alive that's provided by ParaProvider.
+     */
+    disableAutoSessionKeepAlive?: boolean;
+    /**
+     * Disables the ParaModal that's provided by ParaProvider. Use this is you're providing a separate modal in another location in your app.
+     */
+    disableEmbeddedModal?: boolean;
+    /**
+     * RPC url to use for retrieving the embedded wallet balance
+     */
+    rpcUrl?: string;
+    /**
+     * Configuration options for Farcaster mini-apps.
+     */
+    farcasterMiniAppConfig?: FarcasterMiniAppConfig;
+};
+export type ExternalWalletConfig<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> = {
+    /**
+     * A description of your app, displayed in some external wallets.
+     */
+    appDescription?: string;
+    /**
+     * A URL for your app, displayed in some external wallets.
+     */
+    appUrl?: string;
+    /**
+     * An icon for your app, displayed in some external wallets.
+     */
+    appIcon?: string;
+    /**
+     * Config for the EVM external wallets connector using Wagmi.
+     *
+     * NOTE: In addition to this config, you MUST also have the `@getpara/evm-wallet-connectors` package installed.
+     */
+    evmConnector?: {
+        /**
+         * Config for the Para EVM external wallets connector.
+         */
+        config: Omit<ParaEvmProviderConfigNoWallets<chains, transports>, 'appName' | 'appDescription' | 'appUrl' | 'appIcon' | 'projectId'>;
+        /**
+         * Config for the Wagmi provider.
+         */
+        wagmiProviderProps?: ParaWagmiProviderProps;
+    };
+    /**
+     * Config for the Cosmos external wallets connector using Graz.
+     *
+     * NOTE: In addition to this config, you MUST also have the `@getpara/cosmos-wallet-connectors` package installed.
+     */
+    cosmosConnector?: {
+        /**
+         * Config for the Para Cosmos external wallets connector.
+         */
+        config: ParaCosmosProviderConfigNoWallets;
+        /**
+         * Config for the Graz provider.
+         */
+        grazProviderProps?: ParaGrazProviderProps;
+    };
+    /**
+     * Config for the Solana external wallets connector using @solana/wallet-adapter-react.
+     *
+     * NOTE: In addition to this config, you MUST also have the `@getpara/solana-wallet-connectors` package installed.
+     */
+    solanaConnector?: {
+        /**
+         * Config for the Para Solana external wallets connector.
+         */
+        config: Omit<ParaSolanaProviderConfigNoWallets, 'appIdentity'> & Pick<Partial<ParaSolanaProviderConfigNoWallets>, 'appIdentity'>;
+    };
+    /**
+     * Config for any connectors that use Wallet Connect.
+     */
+    walletConnect?: {
+        /**
+         * Your Wallet Connect project ID.
+         */
+        projectId: 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.
+     */
+    wallets?: TExternalWallet[];
+    /**
+     * Array of external wallets that will also include linked embedded wallets. Also includes a wallet verification step.
+     *
+     * You can also pass `ALL` to include linked embedded wallets for all external wallets.
+     */
+    createLinkedEmbeddedForExternalWallets?: TExternalWallet[] | 'ALL';
+    /**
+     * Whether or not to validate a signature from the connected external wallet and create a Para session.
+     *
+     * All wallets using createLinkedEmbeddedForExternalWallets automatically include wallet verification.
+     */
+    includeWalletVerification?: boolean;
+    /**
+     * Whether or not to treat external wallets as connections only, skipping all Para functionality.
+     *
+     * This prop will override the createLinkedEmbeddedForExternalWallets and includeWalletVerification props
+     */
+    connectionOnly?: boolean;
+};
+export interface ParaProviderProps<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> extends PropsWithChildren {
+    /**
+     * Arguments to setup a new Para instance, or a Para instance you have already instantiated.
+     */
+    paraClientConfig: {
+        /**
+         * Environment for your Para instance.
+         */
+        env: Environment;
+        /**
+         * API key for you Para instance.
+         *
+         * NOTE: Be sure this key matches the environment.
+         */
+        apiKey: string;
+        opts?: ConstructorOpts;
+    } | ParaWeb;
+    /**
+     * Configuration used for the Para modal.
+     */
+    paraModalConfig?: ParaModalProps;
+    /**
+     * Callbacks fired for events from the Para instance.
+     */
+    callbacks?: Callbacks;
+    /**
+     * Config for the ParaProvider.
+     */
+    config: ParaProviderConfig;
+    /**
+     * Config for any external wallets.
+     */
+    externalWalletConfig?: ExternalWalletConfig<chains, transports>;
+}

package/dist/provider/types/provider.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/types/query.d.ts

@@ -0,0 +1,3 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { Compute, UnionStrictOmit } from './utils.js';
+export type UseMutationReturnType<data = unknown, error = Error, variables = void, context = unknown> = Compute<UnionStrictOmit<UseMutationResult<data, error, variables, context>, 'mutate' | 'mutateAsync'>>;

package/dist/provider/types/query.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/types/utils.d.ts

@@ -0,0 +1,45 @@
+import ParaWeb, { CoreMethodName, CoreMethodParams, CoreMethodResponse, CoreMethods, InternalMethodName, InternalMethodParams, InternalMethodResponse, InternalMethods } from '@getpara/web-sdk';
+import { UseMutationReturnType } from './query.js';
+import { UseMutateFunction, UseMutateAsyncFunction, MutationState, Mutation, UseQueryResult, Query } from '@tanstack/react-query';
+export type Compute<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+/** Strict version of built-in Omit type */
+export type StrictOmit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+export type UnionStrictOmit<type, keys extends keyof type> = type extends any ? StrictOmit<type, keys> : never;
+export type ChangeFields<T, R> = Omit<T, keyof R> & R;
+type CoreSyncMutationHook<method extends CoreMethodName & keyof CoreMethods> = {
+    mutate: UseMutateFunction<Awaited<CoreMethodResponse<method>>, Error, CoreMethodParams<method> | void, unknown>;
+} & {
+    [K in method]: UseMutateFunction<Awaited<CoreMethodResponse<method>>, Error, CoreMethodParams<method> | void, unknown>;
+};
+type CoreAsyncMutationHook<method extends CoreMethodName & keyof CoreMethods> = {
+    mutateAsync: UseMutateAsyncFunction<CoreMethodResponse<method>, Error, CoreMethodParams<method> | void, unknown>;
+} & {
+    [K in `${method}Async`]: UseMutateAsyncFunction<CoreMethodResponse<method>, Error, CoreMethodParams<method> | void, unknown>;
+};
+export type CoreMethodUseMutationReturnType<method extends CoreMethodName & keyof CoreMethods> = UseMutationReturnType<Awaited<CoreMethodResponse<method>>, Error, CoreMethodParams<method> | void, unknown>;
+export type CoreMethodMutation<method extends CoreMethodName & keyof CoreMethods> = Mutation<Awaited<CoreMethodResponse<method>>, Error, CoreMethodParams<method> | void, unknown>;
+export type CoreMethodQuery<method extends CoreMethodName & keyof CoreMethods> = Query<Awaited<CoreMethodResponse<method>>, Error>;
+export type CoreGetterQuery<name extends keyof typeof ParaWeb> = Query<(typeof ParaWeb)[name] | null, Error>;
+export type CoreMethodMutationState<method extends CoreMethodName & keyof CoreMethods> = MutationState<Awaited<CoreMethodResponse<method>>, Error, CoreMethodParams<method> | void, unknown>;
+export type CoreMethodMutationHook<method extends CoreMethodName & keyof CoreMethods> = Compute<CoreMethodUseMutationReturnType<method> & CoreSyncMutationHook<method> & CoreAsyncMutationHook<method>>;
+export type CoreMethodQueryHook<method extends CoreMethodName & keyof CoreMethods> = UseQueryResult<Awaited<CoreMethodResponse<method>> | null, Error>;
+export type CoreGetterQueryHook<name extends keyof typeof ParaWeb> = UseQueryResult<(typeof ParaWeb)[name] | null, Error>;
+export type CoreMethodMutationStateHook<method extends CoreMethodName & keyof CoreMethods> = () => Omit<CoreMethodUseMutationReturnType<method>, 'reset'>;
+type InternalSyncMutationHook<method extends InternalMethodName & keyof InternalMethods> = {
+    mutate: UseMutateFunction<Awaited<InternalMethodResponse<method>>, Error, InternalMethodParams<method> | void, unknown>;
+};
+type InternalAsyncMutationHook<method extends InternalMethodName & keyof InternalMethods> = {
+    mutateAsync: UseMutateAsyncFunction<InternalMethodResponse<method>, Error, InternalMethodParams<method> | void, unknown>;
+};
+export type InternalMethodUseMutationReturnType<method extends InternalMethodName & keyof InternalMethods> = UseMutationReturnType<Awaited<InternalMethodResponse<method>>, Error, InternalMethodParams<method> | void, unknown>;
+export type InternalMethodMutation<method extends InternalMethodName & keyof InternalMethods> = Mutation<Awaited<InternalMethodResponse<method>>, Error, InternalMethodParams<method> | void, unknown>;
+export type InternalMethodQuery<method extends InternalMethodName & keyof InternalMethods> = Query<Awaited<InternalMethodResponse<method>>, Error>;
+export type InternalGetterQuery<name extends keyof typeof ParaWeb> = Query<(typeof ParaWeb)[name] | null, Error>;
+export type InternalMethodMutationState<method extends InternalMethodName & keyof InternalMethods> = MutationState<Awaited<InternalMethodResponse<method>>, Error, InternalMethodParams<method> | void, unknown>;
+export type InternalMethodMutationHook<method extends InternalMethodName & keyof InternalMethods> = Compute<InternalMethodUseMutationReturnType<method> & InternalSyncMutationHook<method> & InternalAsyncMutationHook<method>>;
+export type InternalMethodQueryHook<method extends InternalMethodName & keyof InternalMethods> = UseQueryResult<Awaited<InternalMethodResponse<method>>, Error>;
+export type InternalGetterQueryHook<name extends keyof typeof ParaWeb> = UseQueryResult<(typeof ParaWeb)[name] | null, Error>;
+export type InternalMethodMutationStateHook<method extends InternalMethodName & keyof InternalMethods> = () => Omit<InternalMethodUseMutationReturnType<method>, 'reset'>;
+export {};

package/dist/provider/types/utils.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EXTERNAL_WALLET_PACKAGE_BY_TYPE: {
+    EVM: string;
+    COSMOS: string;
+    SOLANA: string;
+};

package/dist/provider/utils/constants.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+const EXTERNAL_WALLET_PACKAGE_BY_TYPE = {
+  EVM: "Wagmi",
+  COSMOS: "Graz",
+  SOLANA: "@solana/wallet-adapter-react"
+};
+export {
+  EXTERNAL_WALLET_PACKAGE_BY_TYPE
+};

package/dist/provider/utils/paraConfigTypeGuards.d.ts

@@ -0,0 +1,7 @@
+import ParaWeb, { ConstructorOpts, Environment } from '@getpara/web-sdk';
+export declare function isConfigType(obj: any): obj is {
+    env: Environment;
+    apiKey: string;
+    opts?: ConstructorOpts;
+};
+export declare function isParaWeb(obj: any): obj is ParaWeb;

package/dist/provider/utils/paraConfigTypeGuards.js

@@ -0,0 +1,13 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import ParaWeb from "@getpara/web-sdk";
+function isConfigType(obj) {
+  return !!obj && typeof obj === "object" && "env" in obj && "apiKey" in obj;
+}
+function isParaWeb(obj) {
+  return obj instanceof ParaWeb;
+}
+export {
+  isConfigType,
+  isParaWeb
+};

package/dist/provider/utils/renameMutations.d.ts

@@ -0,0 +1,5 @@
+import { CoreMethodName, CoreMethodParams, CoreMethodResponse, CoreMethods } from '@getpara/web-sdk';
+import { DefaultError, UseMutationResult } from '@tanstack/react-query';
+import { CoreMethodMutationHook } from '../types/utils.js';
+export declare function renameMutations<TResp = unknown, TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(mutationObj: UseMutationResult<TData, TError, TVariables, TContext>, name: string): TResp;
+export declare function renameCoreMutations<method extends CoreMethodName & keyof CoreMethods>(mutationObj: UseMutationResult<CoreMethodResponse<method>, Error, CoreMethodParams<method> | undefined, unknown>, name: method): CoreMethodMutationHook<method>;