@openfort/react 0.0.33 → 0.1.0

package/build/assets/icons.d.ts

@@ -43,3 +43,6 @@ export declare const ShieldIcon: ({ ...props }: {
 export declare const FingerPrintIcon: ({ ...props }: {
     [x: string]: any;
 }) => import("react/jsx-runtime").JSX.Element;
+export declare const PlusIcon: ({ ...props }: {
+    [x: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/build/components/Common/Loading/index.d.ts

@@ -1,6 +1,6 @@
 type LoaderProps = {
     header: string;
-    description?: string | undefined;
+    description?: string | undefined | false;
     isLoading?: boolean;
     icon?: React.ReactNode;
     isError?: boolean;

package/build/components/Common/Modal/index.d.ts

@@ -9,7 +9,6 @@ type ModalProps = {
     positionInside?: boolean;
     inline?: boolean;
     onClose?: () => void;
-    onBack?: () => void;
     onInfo?: () => void;
     demo?: {
         theme: string;

package/build/components/Common/Modal/styles.d.ts

@@ -1,5 +1,4 @@
 export declare const ErrorMessage: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
-export declare const PageContent: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
 export declare const TextWithHr: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {
     $disableHr?: boolean;
 }, never>;

package/build/components/ConnectModal/ConnectWithInjector/index.d.ts

@@ -8,6 +8,8 @@ declare const states: {
     NOTCONNECTED: string;
     UNAVAILABLE: string;
     DUPLICATED: string;
+    SIWE: string;
+    RECOVER_ADDRESS_MISMATCH: string;
 };
 declare const ConnectWithInjector: React.FC<{
     switchConnectMethod: (id?: string) => void;

package/build/components/Openfort/context.d.ts

@@ -1,17 +1,8 @@
-import type { OAuthProvider, SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
+import type { SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import type React from 'react';
-import type { ValueOf } from 'viem/_types/types/utils';
 import type { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import type { CustomTheme, Languages, Mode, Theme } from '../../types';
-import type { OpenfortUIOptionsExtended, OpenfortWalletConfig, routes } from './types';
-type Connector = {
-    id: string;
-    type?: 'wallet';
-} | {
-    id: OAuthProvider;
-    type: 'oauth';
-};
-export type ErrorMessage = string | React.ReactNode | null;
+import type { Connector, ErrorMessage, OpenfortUIOptionsExtended, OpenfortWalletConfig, RouteOptions, SetRouteOptions } from './types';
 export type ContextValue = {
     setTheme: React.Dispatch<React.SetStateAction<Theme>>;
     mode: Mode;
@@ -21,8 +12,14 @@ export type ContextValue = {
     setLang: React.Dispatch<React.SetStateAction<Languages>>;
     open: boolean;
     setOpen: React.Dispatch<React.SetStateAction<boolean>>;
-    route: ValueOf<typeof routes>;
-    setRoute: (r: ValueOf<typeof routes>) => void;
+    route: RouteOptions;
+    setRoute: (options: SetRouteOptions) => void;
+    onBack: (() => void) | null;
+    setOnBack: React.Dispatch<React.SetStateAction<(() => void) | null>>;
+    previousRoute: RouteOptions | null;
+    setPreviousRoute: () => void;
+    routeHistory: RouteOptions[];
+    setRouteHistory: React.Dispatch<React.SetStateAction<RouteOptions[]>>;
     connector: Connector;
     setConnector: React.Dispatch<React.SetStateAction<Connector>>;
     errorMessage: ErrorMessage;
@@ -37,4 +34,3 @@ export type ContextValue = {
     setEmailInput: React.Dispatch<React.SetStateAction<string>>;
 } & useConnectCallbackProps;
 export declare const Openfortcontext: React.Context<ContextValue | null>;
-export {};

package/build/components/Openfort/types.d.ts

@@ -1,12 +1,18 @@
-import type { AccountTypeEnum, RecoveryMethod } from '@openfort/openfort-js';
+import type { AccountTypeEnum, OAuthProvider, RecoveryMethod } from '@openfort/openfort-js';
 import type React from 'react';
 import type { ReactNode } from 'react';
+import type { UserWallet } from '../../hooks/openfort/useWallets';
 import type { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from '../../types';
 export declare const routes: {
     readonly PROVIDERS: "providers";
     readonly SOCIAL_PROVIDERS: "socialProviders";
     readonly LOADING: "loading";
-    readonly RECOVER: "recover";
+    readonly LOAD_WALLETS: "loadWallets";
+    readonly RECOVER_WALLET: "recoverWallets";
+    readonly SELECT_WALLET_TO_RECOVER: "selectWalletToRecover";
+    readonly CREATE_WALLET: "createWallet";
+    readonly CONNECTED: "connected";
+    readonly CREATE_GUEST_USER: "createGuestUser";
     readonly EMAIL_LOGIN: "emailLogin";
     readonly FORGOT_PASSWORD: "forgotPassword";
     readonly EMAIL_VERIFICATION: "emailVerification";
@@ -21,6 +27,34 @@ export declare const routes: {
     readonly PROFILE: "profile";
     readonly SWITCHNETWORKS: "switchNetworks";
 };
+type AllRoutes = (typeof routes)[keyof typeof routes];
+export declare const notStoredInHistoryRoutes: AllRoutes[];
+type ConnectOptions = {
+    connectType: 'link' | 'connect' | 'linkIfUserConnectIfNoUser';
+} | {
+    connectType: 'recover';
+    wallet: UserWallet;
+};
+type RoutesWithOptions = ({
+    route: typeof routes.CONNECTORS;
+} & ConnectOptions) | ({
+    route: typeof routes.CONNECT;
+} & ConnectOptions) | {
+    route: typeof routes.RECOVER_WALLET;
+    wallet: UserWallet;
+};
+export type RoutesWithoutOptions = {
+    route: Exclude<AllRoutes, RoutesWithOptions['route']>;
+};
+export type RouteOptions = RoutesWithoutOptions | RoutesWithOptions;
+export type SetRouteOptions = RouteOptions | RoutesWithoutOptions['route'];
+export type Connector = {
+    id: string;
+    type?: 'wallet';
+} | {
+    id: OAuthProvider;
+    type: 'oauth';
+};
 export declare enum UIAuthProvider {
     GOOGLE = "google",
     TWITTER = "twitter",
@@ -31,7 +65,13 @@ export declare enum UIAuthProvider {
     WALLET = "wallet",
     GUEST = "guest"
 }
+export type ErrorMessage = string | React.ReactNode | null;
 export declare const socialProviders: UIAuthProvider[];
+export declare enum LinkWalletOnSignUpOption {
+    OPTIONAL = "optional",
+    REQUIRED = "required",
+    DISABLED = "disabled"
+}
 type PolicyConfig = string | Record<number, string>;
 type CommonWalletConfig = {
     /** Publishable key for the Shield API. */
@@ -61,7 +101,7 @@ type EncryptionSession = {
  */
 export type OpenfortWalletConfig = CommonWalletConfig & EncryptionSession;
 type OpenfortUIOptions = {
-    linkWalletOnSignUp?: boolean;
+    linkWalletOnSignUp?: LinkWalletOnSignUpOption;
     authProviders: UIAuthProvider[];
     skipEmailVerification?: boolean;
     termsOfServiceUrl?: string;

package/build/components/PageContent/index.d.ts

@@ -0,0 +1,10 @@
+import type { SetRouteOptions } from '../Openfort/types';
+export type SetOnBackFunction = (() => void) | null | 'inherit' | 'back' | SetRouteOptions;
+type PageContentProps = {
+    children?: React.ReactNode;
+    width?: number | string;
+    onBack?: SetOnBackFunction;
+    logoutOnBack?: boolean;
+};
+export declare const PageContent: ({ children, width, onBack, logoutOnBack }: PageContentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/build/components/PageContent/styles.d.ts

@@ -0,0 +1 @@
+export declare const PageContentStyle: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;

package/build/components/Pages/Connected/index.d.ts

@@ -0,0 +1,2 @@
+declare const Connected: React.FC;
+export default Connected;

package/build/components/Pages/Connectors/index.d.ts

@@ -1,3 +1,4 @@
-import type React from 'react';
-declare const Wallets: React.FC;
-export default Wallets;
+declare const Connectors: ({ logoutOnBack }: {
+    logoutOnBack?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default Connectors;

package/build/components/Pages/CreateGuestUserPage/index.d.ts

@@ -0,0 +1,2 @@
+declare const CreateGuestUserPage: () => import("react/jsx-runtime").JSX.Element;
+export default CreateGuestUserPage;

package/build/components/Pages/CreateWallet/index.d.ts

@@ -0,0 +1,2 @@
+declare const CreateWallet: React.FC;
+export default CreateWallet;

package/build/components/Pages/LoadWallets/index.d.ts

@@ -0,0 +1,2 @@
+declare const LoadWallets: React.FC;
+export default LoadWallets;

package/build/components/Pages/SelectWalletToRecover/index.d.ts

@@ -0,0 +1,2 @@
+declare const SelectWalletToRecover: React.FC;
+export default SelectWalletToRecover;

package/build/hooks/openfort/useConnectWithSiwe.d.ts

@@ -1,6 +1,7 @@
+import { type OpenfortErrorType } from '@openfort/openfort-js';
 export declare function useConnectWithSiwe(): ({ onError, onConnect, connectorType: propsConnectorType, walletClientType: propsWalletClientType, }?: {
     connectorType?: string;
     walletClientType?: string;
-    onError?: (error: string, status?: number) => void;
+    onError?: (error: string, openfortError?: OpenfortErrorType) => void;
     onConnect?: () => void;
 }) => Promise<void>;

package/build/hooks/openfort/useExtendedWalletClient.d.ts

@@ -0,0 +1,389 @@
+export declare function useExtendedWalletClient(): import("viem").Client<import("viem").CustomTransport, import("viem").Chain, {
+    client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    } | import("viem").JsonRpcAccount | undefined>;
+    entryPoint: {
+        abi: import("viem").Abi;
+        address: import("viem").Address;
+        version: import("viem/_types/account-abstraction").EntryPointVersion;
+    };
+    extend?: object | undefined;
+    getAddress: () => Promise<import("viem").Address>;
+    decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]>) | undefined | undefined;
+    encodeCalls: (calls: readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]) => Promise<import("viem").Hex>;
+    getFactoryArgs: () => Promise<{
+        factory?: import("viem").Address | undefined;
+        factoryData?: import("viem").Hex | undefined;
+    }>;
+    getNonce: (parameters?: {
+        key?: bigint | undefined;
+    } | undefined) => Promise<bigint>;
+    getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
+    nonceKeyManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signMessage: (parameters: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
+        chainId?: number | undefined;
+    }) => Promise<import("viem").Hex>;
+    userOperation?: {
+        estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
+    } | undefined | undefined;
+    authorization?: undefined | undefined;
+    address: import("viem").Address;
+    isDeployed: () => Promise<boolean>;
+    type: "smart";
+    nonceManager?: undefined;
+    signAuthorization?: undefined;
+    signTransaction?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+} | {
+    client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    } | import("viem").JsonRpcAccount | undefined>;
+    entryPoint: {
+        abi: import("viem").Abi;
+        address: import("viem").Address;
+        version: import("viem/_types/account-abstraction").EntryPointVersion;
+    };
+    extend?: object | undefined;
+    getAddress: () => Promise<import("viem").Address>;
+    decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]>) | undefined | undefined;
+    encodeCalls: (calls: readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]) => Promise<import("viem").Hex>;
+    getFactoryArgs: () => Promise<{
+        factory?: import("viem").Address | undefined;
+        factoryData?: import("viem").Hex | undefined;
+    }>;
+    getNonce: (parameters?: {
+        key?: bigint | undefined;
+    } | undefined) => Promise<bigint>;
+    getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
+    nonceKeyManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signMessage: (parameters: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
+        chainId?: number | undefined;
+    }) => Promise<import("viem").Hex>;
+    userOperation?: {
+        estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
+    } | undefined | undefined;
+    authorization: {
+        account: import("viem").PrivateKeyAccount;
+        address: import("viem").Address;
+    };
+    address: import("viem").Address;
+    isDeployed: () => Promise<boolean>;
+    type: "smart";
+    nonceManager?: undefined;
+    signAuthorization?: undefined;
+    signTransaction?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+} | {
+    address: `0x${string}`;
+    type: "json-rpc";
+    extend?: undefined;
+    nonceManager?: undefined;
+    sign?: undefined;
+    signAuthorization?: undefined;
+    signMessage?: undefined;
+    signTransaction?: undefined;
+    signTypedData?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+    client?: undefined;
+    entryPoint?: undefined;
+    getAddress?: undefined;
+    decodeCalls?: undefined;
+    encodeCalls?: undefined;
+    getFactoryArgs?: undefined;
+    getNonce?: undefined;
+    getStubSignature?: undefined;
+    nonceKeyManager?: undefined;
+    signUserOperation?: undefined;
+    userOperation?: undefined;
+    authorization?: undefined;
+    isDeployed?: undefined;
+} | {
+    address: import("viem").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    publicKey: import("viem").Hex;
+    source: string;
+    type: "local";
+    extend?: undefined;
+    client?: undefined;
+    entryPoint?: undefined;
+    getAddress?: undefined;
+    decodeCalls?: undefined;
+    encodeCalls?: undefined;
+    getFactoryArgs?: undefined;
+    getNonce?: undefined;
+    getStubSignature?: undefined;
+    nonceKeyManager?: undefined;
+    signUserOperation?: undefined;
+    userOperation?: undefined;
+    authorization?: undefined;
+    isDeployed?: undefined;
+}, import("viem").WalletRpcSchema, {
+    grantPermissions: (parameters: import("viem/experimental").GrantPermissionsParameters) => Promise<import("viem/experimental").GrantPermissionsReturnType>;
+} & import("viem").WalletActions<import("viem").Chain, {
+    client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    } | import("viem").JsonRpcAccount | undefined>;
+    entryPoint: {
+        abi: import("viem").Abi;
+        address: import("viem").Address;
+        version: import("viem/_types/account-abstraction").EntryPointVersion;
+    };
+    extend?: object | undefined;
+    getAddress: () => Promise<import("viem").Address>;
+    decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]>) | undefined | undefined;
+    encodeCalls: (calls: readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]) => Promise<import("viem").Hex>;
+    getFactoryArgs: () => Promise<{
+        factory?: import("viem").Address | undefined;
+        factoryData?: import("viem").Hex | undefined;
+    }>;
+    getNonce: (parameters?: {
+        key?: bigint | undefined;
+    } | undefined) => Promise<bigint>;
+    getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
+    nonceKeyManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signMessage: (parameters: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
+        chainId?: number | undefined;
+    }) => Promise<import("viem").Hex>;
+    userOperation?: {
+        estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
+    } | undefined | undefined;
+    authorization?: undefined | undefined;
+    address: import("viem").Address;
+    isDeployed: () => Promise<boolean>;
+    type: "smart";
+    nonceManager?: undefined;
+    signAuthorization?: undefined;
+    signTransaction?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+} | {
+    client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    } | import("viem").JsonRpcAccount | undefined>;
+    entryPoint: {
+        abi: import("viem").Abi;
+        address: import("viem").Address;
+        version: import("viem/_types/account-abstraction").EntryPointVersion;
+    };
+    extend?: object | undefined;
+    getAddress: () => Promise<import("viem").Address>;
+    decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]>) | undefined | undefined;
+    encodeCalls: (calls: readonly {
+        to: import("viem").Hex;
+        data?: import("viem").Hex | undefined;
+        value?: bigint | undefined;
+    }[]) => Promise<import("viem").Hex>;
+    getFactoryArgs: () => Promise<{
+        factory?: import("viem").Address | undefined;
+        factoryData?: import("viem").Hex | undefined;
+    }>;
+    getNonce: (parameters?: {
+        key?: bigint | undefined;
+    } | undefined) => Promise<bigint>;
+    getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
+    nonceKeyManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signMessage: (parameters: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
+        chainId?: number | undefined;
+    }) => Promise<import("viem").Hex>;
+    userOperation?: {
+        estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
+    } | undefined | undefined;
+    authorization: {
+        account: import("viem").PrivateKeyAccount;
+        address: import("viem").Address;
+    };
+    address: import("viem").Address;
+    isDeployed: () => Promise<boolean>;
+    type: "smart";
+    nonceManager?: undefined;
+    signAuthorization?: undefined;
+    signTransaction?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+} | {
+    address: `0x${string}`;
+    type: "json-rpc";
+    extend?: undefined;
+    nonceManager?: undefined;
+    sign?: undefined;
+    signAuthorization?: undefined;
+    signMessage?: undefined;
+    signTransaction?: undefined;
+    signTypedData?: undefined;
+    publicKey?: undefined;
+    source?: undefined;
+    client?: undefined;
+    entryPoint?: undefined;
+    getAddress?: undefined;
+    decodeCalls?: undefined;
+    encodeCalls?: undefined;
+    getFactoryArgs?: undefined;
+    getNonce?: undefined;
+    getStubSignature?: undefined;
+    nonceKeyManager?: undefined;
+    signUserOperation?: undefined;
+    userOperation?: undefined;
+    authorization?: undefined;
+    isDeployed?: undefined;
+} | {
+    address: import("viem").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    publicKey: import("viem").Hex;
+    source: string;
+    type: "local";
+    extend?: undefined;
+    client?: undefined;
+    entryPoint?: undefined;
+    getAddress?: undefined;
+    decodeCalls?: undefined;
+    encodeCalls?: undefined;
+    getFactoryArgs?: undefined;
+    getNonce?: undefined;
+    getStubSignature?: undefined;
+    nonceKeyManager?: undefined;
+    signUserOperation?: undefined;
+    userOperation?: undefined;
+    authorization?: undefined;
+    isDeployed?: undefined;
+}>> | undefined;