@naculus/connect-appkit-vue 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { StencilVueComponent } from '@stencil/vue-output-target/runtime';
 import { JSX } from '@naculus/connect-appkit-wc';
-import { ComputedRef, MaybeRefOrGetter, shallowRef, ref, ShallowRef } from 'vue';
-import { WalletChain, ChainInfo, ChainCapabilities, AtomicSupport, SolanaRoles, SolanaRolesAbsence, SolanaIdentity, SolanaSigner, SolanaPayer, SolanaRolesSource } from '@naculus/connect-appkit-core';
+import { ComputedRef, MaybeRefOrGetter, MaybeRef, ShallowRef, shallowRef, ref } from 'vue';
+import { NotificationSettingsStorage, WalletChain, SimulationCallClient, SimulationTransaction, SiwxResultLike, PolicySignatureVerifier, PolicyExecutionPreview, PolicyExecutionAdapter, DelegationPolicyPreview, PolicyExecutionSubmission, SmartAccountType, RouteQuote, RouteQuoteInput, GetRouteQuotes, CostComparison, CompareCostsInput, CompareCosts, ExecutableQuote, ExecuteRouteOptions, ExecuteRouteResult, ExecuteRouteError, ExecuteRoute, DestinationValidation, ChainInfo, ChainCapabilities, AtomicSupport, SolanaRoles, SolanaRolesAbsence, SolanaIdentity, SolanaSigner, SolanaPayer, SolanaRolesSource } from '@naculus/connect-appkit-core';
 export { AtomicSupport, ChainCapabilities, SolanaIdentity, SolanaPayer, SolanaRoles, SolanaRolesAbsence, SolanaRolesSource, SolanaSigner, SolanaWalletFeatures } from '@naculus/connect-appkit-core';
-import { PassphraseGate } from '@naculus/connect-core';
+import { InAppChannel, NotificationItem, NotificationSettings, SimulationResult, ERC20_MIN_ABI, TokenConfig, ActiveSessionBundle, ChainSession, SessionManager, WalletError, SolanaConfirmationStatus, BatchCall, AtomicityRequirement, ExecutionPlan, CallsStatus, ExecutionStrategy, SessionKeyManagerConfig, SessionKeyManager, SessionKeyInfo, SessionKeyScope, SessionKeyTransaction, Address, SmartAccountManager, SmartAccountInfo, SmartAccountConfig, Hex, Call, SendUserOpOptions, UserOperationResponse, UserOperationReceipt, ScopeCheckResult, TokenListSource, TokenListManager, TokenListEntry, TokenSearchResult, AddressResult, NameResolverConfig, NameResult, PassphraseGate } from '@naculus/connect-core';
 
 declare const AppkitAccordion: StencilVueComponent<JSX.AppkitAccordion>;
 declare const AppkitAccountButton: StencilVueComponent<JSX.AppkitAccountButton>;
@@ -56,6 +56,882 @@ interface UseAccountsReturn {
  */
 declare function useAccounts(accounts: MaybeRefOrGetter<string[] | null | undefined>): UseAccountsReturn;
 
+interface UseNotificationOptions {
+    channel?: MaybeRef<InAppChannel>;
+    storage?: MaybeRef<NotificationSettingsStorage>;
+}
+interface UseNotificationReturn {
+    notifications: ShallowRef<NotificationItem[]>;
+    unreadCount: ComputedRef<number>;
+    settings: ShallowRef<NotificationSettings>;
+    addNotification: (item: Omit<NotificationItem, "id" | "timestamp">) => void;
+    clear: () => void;
+    clearOne: (id: string) => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+    updateSettings: (update: Partial<NotificationSettings>) => void;
+    setChannels: (channels: string[]) => void;
+    muteChain: (chainId: string) => void;
+    unmuteChain: (chainId: string) => void;
+}
+/** Vue state shell over the shared in-app notification actions. */
+declare function useNotification(options?: UseNotificationOptions): UseNotificationReturn;
+
+interface UseSimulateTransferOptions {
+    rpcUrl?: MaybeRef<string | undefined>;
+    chainId?: MaybeRef<number | undefined>;
+}
+interface UseSimulateTransferReturn {
+    result: ShallowRef<SimulationResult | null>;
+    loading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    simulate: (tokenAddress: `0x${string}`, from: `0x${string}`, to: `0x${string}`, amount: string, options?: {
+        chainId?: number;
+        rpcUrl?: string;
+        decimals?: number;
+    }) => Promise<SimulationResult>;
+    reset: () => void;
+}
+/** Vue state shell around the canonical connect-core ERC-20 simulator. */
+declare function useSimulateTransfer(options?: UseSimulateTransferOptions): UseSimulateTransferReturn;
+
+interface UseTransactionSimulationOptions {
+    chainId?: MaybeRef<number | undefined>;
+    currentChain?: MaybeRef<WalletChain | null | undefined>;
+    publicClient?: MaybeRef<SimulationCallClient | null | undefined>;
+    evmAccount?: MaybeRef<string | null | undefined>;
+}
+interface UseTransactionSimulationReturn {
+    result: ShallowRef<SimulationResult | undefined>;
+    isSimulating: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    simulate: () => Promise<SimulationResult>;
+    reset: () => void;
+}
+/** Basic eth_call preview; caller supplies chain/account/client context. */
+declare function useTransactionSimulation(tx: MaybeRefOrGetter<SimulationTransaction | undefined>, options?: UseTransactionSimulationOptions): UseTransactionSimulationReturn;
+
+interface ERC20Reader {
+    readContract(args: {
+        address: `0x${string}`;
+        abi: typeof ERC20_MIN_ABI;
+        functionName: "decimals" | "allowance";
+        args?: readonly [`0x${string}`, `0x${string}`];
+    }): Promise<unknown>;
+}
+interface ERC20Transaction {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value: "0";
+}
+type ERC20Sender = (transaction: ERC20Transaction) => Promise<`0x${string}`>;
+
+interface UseERC20TransferOptions {
+    token: MaybeRefOrGetter<TokenConfig>;
+    account: MaybeRefOrGetter<string | null | undefined>;
+    chainId: MaybeRefOrGetter<number | undefined>;
+    connected: MaybeRefOrGetter<boolean>;
+    publicClient: MaybeRefOrGetter<ERC20Reader | null | undefined>;
+    sendTransaction: MaybeRef<ERC20Sender>;
+}
+interface UseERC20TransferReturn {
+    sendTransfer: (to: `0x${string}`, amount: string) => Promise<`0x${string}`>;
+    isSending: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+}
+/** Vue state shell for an ERC-20 transfer through a caller-owned send action. */
+declare function useERC20Transfer(options: UseERC20TransferOptions): UseERC20TransferReturn;
+
+interface UseERC20ApproveOptions {
+    token: MaybeRefOrGetter<TokenConfig>;
+    spender: MaybeRefOrGetter<`0x${string}`>;
+    account: MaybeRefOrGetter<string | null | undefined>;
+    chainId: MaybeRefOrGetter<number | undefined>;
+    connected: MaybeRefOrGetter<boolean>;
+    publicClient: MaybeRefOrGetter<ERC20Reader | null | undefined>;
+    sendTransaction: MaybeRef<ERC20Sender>;
+}
+interface UseERC20ApproveReturn {
+    approve: (amount: string) => Promise<`0x${string}`>;
+    approveMax: () => Promise<`0x${string}`>;
+    allowanceRaw: ShallowRef<bigint | null>;
+    allowance: ComputedRef<string | null>;
+    hasAllowance: (required: string) => Promise<boolean>;
+    isApproving: ShallowRef<boolean>;
+    isFetchingAllowance: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refetchAllowance: () => Promise<bigint | null>;
+}
+/** Vue state shell for ERC-20 approvals through caller-owned read/send actions. */
+declare function useERC20Approve(options: UseERC20ApproveOptions): UseERC20ApproveReturn;
+
+interface UseERC20TransferSimulationOptions {
+    token: MaybeRefOrGetter<TokenConfig>;
+    to: MaybeRefOrGetter<`0x${string}`>;
+    amount: MaybeRefOrGetter<string>;
+    connected: MaybeRefOrGetter<boolean>;
+    evmAccount: MaybeRef<string | null | undefined>;
+    currentChain?: MaybeRef<WalletChain | null | undefined>;
+    publicClient?: MaybeRef<SimulationCallClient | null | undefined>;
+}
+interface UseERC20TransferSimulationReturn extends Omit<UseTransactionSimulationReturn, "result" | "isSimulating" | "error" | "simulate"> {
+    result: ComputedRef<SimulationResult | undefined>;
+    isSimulating: ComputedRef<boolean>;
+    error: ComputedRef<Error | null>;
+    reSimulate: () => Promise<SimulationResult>;
+}
+/** Vue shell that previews exactly the calldata accepted by the transfer hook. */
+declare function useERC20TransferSimulation(options: UseERC20TransferSimulationOptions): UseERC20TransferSimulationReturn;
+
+interface UseAccountReturn {
+    accounts: ComputedRef<AccountEntry[] | null>;
+    evmAccount: ComputedRef<string | null>;
+    primaryAccount: ComputedRef<string | null>;
+    isConnected: ComputedRef<boolean>;
+    count: ComputedRef<number>;
+}
+/** React useAccount's connected-state view of the shared account parser. */
+declare function useAccount(accounts: MaybeRefOrGetter<string[] | null | undefined>, connected: MaybeRefOrGetter<boolean>): UseAccountReturn;
+
+interface UseSessionReturn {
+    session: ComputedRef<ActiveSessionBundle["walletSession"] | null>;
+    chainSessions: ComputedRef<ChainSession[]>;
+    activeChainId: ComputedRef<string | null>;
+    isConnected: ComputedRef<boolean>;
+    connectorId: ComputedRef<string | null>;
+}
+/** Reactively expose a caller-owned SessionManager's active bundle. */
+declare function useSession(manager: MaybeRefOrGetter<SessionManager | null | undefined>): UseSessionReturn;
+
+interface UseConnectReturn {
+    connect: () => Promise<void>;
+    isConnecting: ComputedRef<boolean>;
+    error: ShallowRef<Error | null>;
+}
+/** Connection state around a caller-owned action; never connects on mount. */
+declare function useConnect(action: MaybeRef<() => Promise<void>>, status: MaybeRefOrGetter<string>): UseConnectReturn;
+
+interface UseDisconnectReturn {
+    disconnect: () => Promise<void>;
+    isDisconnecting: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    cleanup: () => void;
+}
+/** Disconnect through a caller-owned action, preserving React's no-op when already disconnected. */
+declare function useDisconnect(action: MaybeRef<() => Promise<void>>, status: MaybeRefOrGetter<string>): UseDisconnectReturn;
+
+interface UseSwitchChainReturn {
+    switchChain: (chainId: string) => Promise<void>;
+    isSwitching: ShallowRef<boolean>;
+    currentChainId: ComputedRef<string | null>;
+    error: ShallowRef<WalletError | null>;
+    clearError: () => void;
+}
+/** Vue counterpart of React useSwitchChain around a caller-owned action. */
+declare function useSwitchChain(action: MaybeRef<(chainId: string) => Promise<void>>, chainId: MaybeRefOrGetter<string | null | undefined>): UseSwitchChainReturn;
+
+type SignMessageAction = (message: string) => Promise<string>;
+interface UseSignMessageReturn {
+    signMessage: SignMessageAction;
+    isSigning: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    reset: () => void;
+}
+/** Reactive state around a caller-owned message-signing action. */
+declare function useSignMessage(action: MaybeRef<SignMessageAction>): UseSignMessageReturn;
+
+interface EvmTransaction {
+    to: string;
+    from?: string;
+    value?: string;
+    data?: string;
+    gas?: string;
+    gasPrice?: string;
+    nonce?: string;
+    chainId?: number;
+}
+type SendTransactionAction = (transaction: EvmTransaction) => Promise<string>;
+type SendTransactionStatus = "idle" | "awaiting_approval" | "submitted" | "failed";
+interface UseSendTransactionReturn {
+    sendTransaction: SendTransactionAction;
+    status: ShallowRef<SendTransactionStatus>;
+    error: ShallowRef<Error | null>;
+    reset: () => void;
+    isSending: ComputedRef<boolean>;
+}
+/** Reactive state around a caller-owned EVM transaction action. */
+declare function useSendTransaction(action: MaybeRef<SendTransactionAction>): UseSendTransactionReturn;
+
+type SolanaTransaction = Uint8Array | string;
+type SignSolanaTransactionAction = (transaction: SolanaTransaction) => Promise<Uint8Array>;
+type SendSolanaTransactionAction = (transaction: SolanaTransaction) => Promise<string>;
+type GetSolanaTransactionStatusAction = (signature: string) => Promise<{
+    status: SolanaConfirmationStatus;
+    error: string | null;
+}>;
+interface UseSolanaTransactionOptions {
+    signTransaction: MaybeRef<SignSolanaTransactionAction>;
+    sendTransaction: MaybeRef<SendSolanaTransactionAction>;
+    getStatus: MaybeRef<GetSolanaTransactionStatusAction>;
+}
+interface UseSolanaTransactionReturn {
+    signTransaction: SignSolanaTransactionAction;
+    sendTransaction: SendSolanaTransactionAction;
+    getStatus: GetSolanaTransactionStatusAction;
+    isSigning: ShallowRef<boolean>;
+    isSending: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    reset: () => void;
+}
+/** Reactive state around caller-owned Solana sign, send, and status actions. */
+declare function useSolanaTransaction(options: UseSolanaTransactionOptions): UseSolanaTransactionReturn;
+
+interface SiwxSignInOptions {
+    domain?: string;
+    statement?: string;
+    uri?: string;
+    chainId?: string;
+    expirySeconds?: number;
+    resources?: string[];
+    requestId?: string;
+}
+type SiwxResult = SiwxResultLike;
+type SiwxSignInAction = (options?: SiwxSignInOptions) => Promise<SiwxResult>;
+interface SiwxSessionLike {
+    id: string;
+    chainId: string;
+    address: string;
+    domain: string;
+    message: SiwxResult["message"];
+    signature: string;
+    issuedAt: string;
+    expiresAt: string | null;
+    refreshedAt: string | null;
+}
+
+interface UseSignInWithXReturn {
+    signIn: SiwxSignInAction;
+    isSigningIn: ShallowRef<boolean>;
+    result: ShallowRef<SiwxResult | null>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+    reset: () => void;
+}
+/** Reactive state around a caller-owned SIWX sign-in action. */
+declare function useSignInWithX(action: MaybeRef<SiwxSignInAction>): UseSignInWithXReturn;
+
+type UseSignInWithEthereumOptions = SiwxSignInOptions;
+interface UseSignInWithEthereumReturn extends UseSignInWithXReturn {
+}
+/** Ethereum-named view of the caller-owned SIWX sign-in shell. */
+declare function useSignInWithEthereum(action: MaybeRef<SiwxSignInAction>): UseSignInWithEthereumReturn;
+
+interface PaymasterService {
+    url: string;
+    context?: Record<string, unknown>;
+}
+interface SendCallsOptions {
+    chainId?: string;
+    strategy?: ExecutionStrategy;
+    paymasterService?: PaymasterService;
+}
+type SendCallsAction = (calls: BatchCall[], options?: SendCallsOptions) => Promise<string>;
+type GetCallsStatusAction = (hash?: string) => Promise<CallsStatus>;
+type ShowCallsStatusAction = (hash?: string) => Promise<boolean>;
+type ExecutionRoute = "wallet-batch" | "user-operation" | "sequential";
+interface ExecutionPreview extends ExecutionPlan {
+    route: ExecutionRoute | null;
+}
+type PreviewExecutionAction = (callCount: number, atomicity?: AtomicityRequirement) => ExecutionPreview;
+type ExecuteCallsAction = (calls: BatchCall[], atomicity?: AtomicityRequirement) => Promise<string>;
+
+interface UseExecuteCallsOptions {
+    preview: MaybeRef<PreviewExecutionAction>;
+    execute: MaybeRef<ExecuteCallsAction>;
+    lastRoute: MaybeRefOrGetter<ExecutionRoute | null>;
+    reset: MaybeRef<() => void>;
+}
+interface UseExecuteCallsReturn {
+    preview: PreviewExecutionAction;
+    execute: ExecuteCallsAction;
+    isExecuting: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    lastRoute: ComputedRef<ExecutionRoute | null>;
+    reset: () => void;
+}
+/** Reactive state around a caller-owned EIP-5792 execution planner/action. */
+declare function useExecuteCalls(options: UseExecuteCallsOptions): UseExecuteCallsReturn;
+
+interface UseDelegationPolicyOptions {
+    /** Connected EOA (plain or CAIP-10). */
+    account: MaybeRefOrGetter<string | null | undefined>;
+    /** Whether a wallet session is connected (gates the policy list). */
+    connected: MaybeRefOrGetter<boolean>;
+    /** Main-wallet EIP-191 signer for the policy message. */
+    signMessage: MaybeRef<(message: string) => Promise<string>>;
+    /** Recovers an EIP-191 signer and compares; e.g. viem's recoverMessageAddress. */
+    verifySignature: MaybeRef<PolicySignatureVerifier>;
+    /** Execution planner (from useExecuteCalls-style preview) for readiness. */
+    previewExecution: MaybeRef<(callCount: number, atomicity: AtomicityRequirement) => PolicyExecutionPreview>;
+    /** Current on-chain EIP-7702 delegation of the account (from useDelegation). */
+    delegation: MaybeRefOrGetter<{
+        delegated: boolean | null;
+        delegate: `0x${string}` | null;
+    }>;
+    managerConfig?: SessionKeyManagerConfig;
+    /** Reuse a caller-owned manager instead of the shared one. */
+    manager?: SessionKeyManager;
+    origin?: string;
+    sponsorship?: AtomicityRequirement;
+    adapter?: PolicyExecutionAdapter;
+}
+interface UseDelegationPolicyReturn {
+    policies: ShallowRef<SessionKeyInfo[]>;
+    /** Active policies whose stored signature currently verifies. */
+    activePolicies: ComputedRef<SessionKeyInfo[]>;
+    storageAvailable: boolean;
+    loading: ComputedRef<boolean>;
+    isBusy: ShallowRef<boolean>;
+    error: ComputedRef<Error | null>;
+    createPolicy: (scope: Partial<SessionKeyScope>) => Promise<SessionKeyInfo>;
+    revokePolicy: (policyId: string) => Promise<void>;
+    previewPolicyExecution: (policyId: string, tx: SessionKeyTransaction, callCount?: number, atomicity?: AtomicityRequirement) => Promise<DelegationPolicyPreview>;
+    signPolicyDigest: (policyId: string, digest: `0x${string}`, tx: SessionKeyTransaction) => Promise<`0x${string}`>;
+    executePolicy: (policyId: string, tx: SessionKeyTransaction) => Promise<PolicyExecutionSubmission>;
+    refresh: () => Promise<void>;
+    clearError: () => void;
+}
+/**
+ * Signed off-chain delegation policies in Vue. The whole flow is
+ * appkit-core's createDelegationPolicyFlow, shared with React; this file
+ * supplies reactivity and the caller-owned signer, verifier, planner and
+ * delegation state that React gets from its provider.
+ */
+declare function useDelegationPolicy(options: UseDelegationPolicyOptions): UseDelegationPolicyReturn;
+
+/** What deployWallet needs from the caller: something that sends an EVM transaction. */
+type DeployTransactionSender = (transaction: {
+    to: Address;
+    data: `0x${string}`;
+    value: string;
+    chainId: string;
+}) => Promise<Address>;
+interface UseSmartAccountOptions {
+    /** Connected EOA (plain or CAIP-10); becomes the smart-account owner. */
+    account: MaybeRefOrGetter<string | null | undefined>;
+    /** Connected chain (CAIP-2), if any. */
+    connectedChainId: MaybeRefOrGetter<string | null | undefined>;
+    rpcUrl: MaybeRefOrGetter<string | undefined>;
+    bundlerUrl?: MaybeRefOrGetter<string | undefined>;
+    chainId?: MaybeRefOrGetter<string | undefined>;
+    entryPoint?: Address;
+    accountType?: SmartAccountType;
+    salt?: bigint;
+    /** Required for deployWallet; the connected wallet's sendTransaction. */
+    sendTransaction?: MaybeRef<DeployTransactionSender | null | undefined>;
+    /** Reuse a caller-owned manager instead of constructing one. */
+    manager?: MaybeRefOrGetter<SmartAccountManager | null | undefined>;
+}
+interface UseSmartAccountReturn {
+    address: ShallowRef<Address | null>;
+    isDeployed: ShallowRef<boolean>;
+    accountInfo: ShallowRef<SmartAccountInfo | null>;
+    isLoading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    /** Null until rpcUrl, chain and owner are all known. */
+    config: ComputedRef<SmartAccountConfig | null>;
+    createWallet: () => Promise<SmartAccountInfo | null>;
+    deployWallet: () => Promise<Address | null>;
+    getAddress: () => Promise<Address | null>;
+}
+/**
+ * Counterfactual smart-account address, deployment state and deployment,
+ * mirroring the React hook. Address derivation, factory calldata and the
+ * refusal to broadcast from the manager are connect-core's; chain and
+ * config decisions are appkit-core's. Deployment is sent through the
+ * caller's own transaction sender, never by this composable.
+ */
+declare function useSmartAccount(options: UseSmartAccountOptions): UseSmartAccountReturn;
+
+/** Signs the 32-byte UserOperation hash. Raw or EIP-191, per signerMode. */
+type UserOpSigner = (hash: Hex) => Promise<Hex> | Hex;
+interface UseSendUserOperationOptions {
+    account: MaybeRefOrGetter<string | null | undefined>;
+    connectedChainId: MaybeRefOrGetter<string | null | undefined>;
+    rpcUrl: MaybeRefOrGetter<string | undefined>;
+    bundlerUrl: MaybeRefOrGetter<string | undefined>;
+    chainId?: MaybeRefOrGetter<string | undefined>;
+    entryPoint?: Address;
+    accountType?: SmartAccountType;
+    salt?: bigint;
+    /** Override the connected account as the smart-account owner. */
+    owner?: MaybeRefOrGetter<Address | undefined>;
+    /**
+     * Required. Vue has no wallet provider to fall back to, so the caller
+     * supplies the signer for the UserOperation hash. Its output is validated
+     * by the manager, not trusted.
+     */
+    signer: MaybeRef<UserOpSigner>;
+    signerMode?: "raw" | "eip191";
+}
+interface UseSendUserOperationReturn {
+    sendUserOp: (calls: Call[], opts?: SendUserOpOptions) => Promise<UserOperationResponse | null>;
+    userOpHash: ShallowRef<Hex | null>;
+    receipt: ShallowRef<UserOperationReceipt | null>;
+    isPending: ShallowRef<boolean>;
+    isEstimating: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    reset: () => void;
+}
+/**
+ * Build, sign and submit one UserOperation, mirroring the React hook.
+ * Preconditions fail closed before anything is signed: configured URLs,
+ * at least one call, a resolvable chain that matches the connected one, an
+ * owner address. Only one operation may be in flight; a result for a
+ * superseded request is dropped.
+ */
+declare function useSendUserOperation(options: UseSendUserOperationOptions): UseSendUserOperationReturn;
+
+type UserOpStatus = "idle" | "pending" | "confirmed" | "failed" | "not_found";
+interface UseUserOpStatusOptions {
+    bundlerUrl: MaybeRefOrGetter<string | undefined>;
+    /** Poll interval in ms (default 2000). */
+    pollInterval?: number;
+    /** Attempts before giving up as not_found (default 30). */
+    maxRetries?: number;
+}
+interface UseUserOpStatusReturn {
+    status: ShallowRef<UserOpStatus>;
+    receipt: ShallowRef<UserOperationReceipt | null>;
+    userOpHash: ShallowRef<Hex | null>;
+    error: ShallowRef<Error | null>;
+    isPolling: ShallowRef<boolean>;
+    elapsedMs: ShallowRef<number>;
+    attempts: ShallowRef<number>;
+    start: (hash: Hex) => void;
+    stop: () => void;
+    reset: () => void;
+}
+/**
+ * Poll a bundler for a UserOperation receipt, mirroring the React hook.
+ * Receipt validation is appkit-core's: a malformed receipt ends polling as
+ * not_found rather than being retried or banked; transport errors retry up
+ * to maxRetries. A start() or dispose aborts the in-flight request.
+ */
+declare function useUserOpStatus(options: UseUserOpStatusOptions): UseUserOpStatusReturn;
+
+/**
+ * Vue counterparts of the React session-key hooks. The SessionKeyManager —
+ * key generation, encryption at rest, scope enforcement, fail-closed signing
+ * — is connect-core's; the shared instance and its config guard are
+ * appkit-core's. These composables only add reactivity. Private key material
+ * never reaches them: signWithSession returns a signature, not a key.
+ */
+interface SessionKeyComposableOptions {
+    /** Reuse a caller-owned manager instead of the shared process-wide one. */
+    manager?: SessionKeyManager;
+}
+interface UseSessionKeysReturn {
+    sessions: ShallowRef<SessionKeyInfo[]>;
+    activeSessions: ComputedRef<SessionKeyInfo[]>;
+    loading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refresh: () => Promise<void>;
+    clearError: () => void;
+    storageAvailable: boolean;
+}
+/**
+ * Lists session keys while a wallet session is connected; an empty list
+ * otherwise, as in React. `connected` is the caller's session state.
+ */
+declare function useSessionKeys(connected: MaybeRefOrGetter<boolean>, config?: SessionKeyManagerConfig, options?: SessionKeyComposableOptions): UseSessionKeysReturn;
+interface UseCreateSessionKeyReturn {
+    createSessionKey: (scope?: Partial<SessionKeyScope>, signerAddress?: `0x${string}`) => Promise<SessionKeyInfo>;
+    lastCreated: ShallowRef<SessionKeyInfo | null>;
+    isCreating: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+declare function useCreateSessionKey(config?: SessionKeyManagerConfig, options?: SessionKeyComposableOptions): UseCreateSessionKeyReturn;
+interface UseRevokeSessionReturn {
+    revokeSession: (sessionId: string) => Promise<void>;
+    isRevoking: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+/** Revocation is device-local: a bundle already handed out cannot be recalled. */
+declare function useRevokeSession(config?: SessionKeyManagerConfig, options?: SessionKeyComposableOptions): UseRevokeSessionReturn;
+interface UseSendWithSessionReturn {
+    signWithSession: (sessionId: string, messageHash: `0x${string}`, tx: SessionKeyTransaction) => Promise<`0x${string}`>;
+    checkScope: (sessionId: string, tx: SessionKeyTransaction) => Promise<ScopeCheckResult>;
+    isBusy: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+declare function useSendWithSession(config?: SessionKeyManagerConfig, options?: SessionKeyComposableOptions): UseSendWithSessionReturn;
+
+type SendCallsStatus = "idle" | "awaiting_approval" | "submitted" | "failed";
+interface UseSendCallsOptions {
+    sendCalls: MaybeRef<SendCallsAction>;
+    getCallsStatus: MaybeRef<GetCallsStatusAction>;
+    showCallsStatus: MaybeRef<ShowCallsStatusAction>;
+    execution?: MaybeRefOrGetter<ExecutionStrategy | null>;
+}
+interface UseSendCallsReturn {
+    sendCalls: SendCallsAction;
+    getCallsStatus: GetCallsStatusAction;
+    showCallsStatus: ShowCallsStatusAction;
+    status: ShallowRef<SendCallsStatus>;
+    error: ShallowRef<Error | null>;
+    batchHash: ShallowRef<string | null>;
+    callsStatus: ShallowRef<CallsStatus | null>;
+    execution: ComputedRef<ExecutionStrategy | null>;
+    isSending: ComputedRef<boolean>;
+    reset: () => void;
+}
+/** Reactive state around caller-owned EIP-5792 actions and execution policy. */
+declare function useSendCalls(options: UseSendCallsOptions): UseSendCallsReturn;
+
+interface EmbeddedWalletAccountView {
+    namespace: string;
+    address: string;
+    derivationPath?: string;
+}
+interface EmbeddedWalletView {
+    accounts: EmbeddedWalletAccountView[];
+    activeNamespace: string;
+    createdAt: number;
+    chainId?: string;
+    version?: 2;
+    recoveryAvailable: boolean;
+    readonly address?: string;
+}
+interface UseEmbeddedWalletOptions<TWalletData, TSecurityReport> {
+    wallet: MaybeRefOrGetter<EmbeddedWalletView | null>;
+    backupPending: MaybeRefOrGetter<boolean>;
+    storageSecurityLevel: MaybeRefOrGetter<number>;
+    securityReport: MaybeRefOrGetter<TSecurityReport | null>;
+    connectEmbedded: MaybeRef<() => Promise<void>>;
+    restoreWallet: MaybeRef<() => Promise<boolean>>;
+    generateWallet: MaybeRef<() => Promise<TWalletData | null>>;
+    importFromMnemonic: MaybeRef<(mnemonic: string) => Promise<TWalletData | null>>;
+    importFromPrivateKey: MaybeRef<(privateKey: string) => Promise<TWalletData | null>>;
+    wipe: MaybeRef<() => Promise<void>>;
+    setActiveNamespace: MaybeRef<(namespace: string) => void>;
+    backfillAccounts: MaybeRef<() => Promise<EmbeddedWalletAccountView[]>>;
+    getSeedPhrase: MaybeRef<() => string | null>;
+    getPrivateKey: MaybeRef<() => string | null>;
+    confirmBackup: MaybeRef<() => void>;
+}
+interface UseEmbeddedWalletReturn<TWalletData, TSecurityReport> {
+    wallet: ComputedRef<EmbeddedWalletView | null>;
+    hasWallet: ComputedRef<boolean>;
+    address: ComputedRef<string | null>;
+    accounts: ComputedRef<EmbeddedWalletAccountView[]>;
+    activeNamespace: ComputedRef<string | null>;
+    backupPending: ComputedRef<boolean>;
+    storageSecurityLevel: ComputedRef<number>;
+    securityReport: ComputedRef<TSecurityReport | null>;
+    connectEmbedded: () => Promise<void>;
+    restoreWallet: () => Promise<boolean>;
+    generateWallet: () => Promise<TWalletData | null>;
+    importFromMnemonic: (mnemonic: string) => Promise<TWalletData | null>;
+    importFromPrivateKey: (privateKey: string) => Promise<TWalletData | null>;
+    wipe: () => Promise<void>;
+    setActiveNamespace: (namespace: string) => void;
+    backfillAccounts: () => Promise<EmbeddedWalletAccountView[]>;
+    getSeedPhrase: () => string | null;
+    getPrivateKey: () => string | null;
+    confirmBackup: () => void;
+    isBusy: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+/** Reactive view over caller-owned embedded-wallet state and actions. */
+declare function useEmbeddedWallet<TWalletData = unknown, TSecurityReport = unknown>(options: UseEmbeddedWalletOptions<TWalletData, TSecurityReport>): UseEmbeddedWalletReturn<TWalletData, TSecurityReport>;
+
+interface UseSIWxLoginReturn {
+    signIn: SiwxSignInAction;
+    isSigningIn: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+/** Login-shaped view of the shared caller-owned SIWX sign-in shell. */
+declare function useSIWxLogin(action: MaybeRef<SiwxSignInAction>): UseSIWxLoginReturn;
+
+interface UseSIWxSessionOptions {
+    session: MaybeRefOrGetter<SiwxSessionLike | null>;
+    isRestoring: MaybeRefOrGetter<boolean>;
+    isExpired: MaybeRefOrGetter<boolean>;
+    timeUntilExpiry: MaybeRefOrGetter<number | null>;
+    signIn: MaybeRef<(options?: SiwxSignInOptions) => Promise<SiwxSessionLike>>;
+    signOut: MaybeRef<() => Promise<void>>;
+    refresh: MaybeRef<() => Promise<SiwxSessionLike>>;
+}
+interface UseSIWxSessionReturn {
+    session: ComputedRef<SiwxSessionLike | null>;
+    isAuthenticated: ComputedRef<boolean>;
+    isRestoring: ComputedRef<boolean>;
+    isSigningIn: ShallowRef<boolean>;
+    isExpired: ComputedRef<boolean>;
+    timeUntilExpiry: ComputedRef<number | null>;
+    signIn: (options?: SiwxSignInOptions) => Promise<SiwxSessionLike>;
+    signOut: () => Promise<void>;
+    refresh: () => Promise<SiwxSessionLike>;
+    error: ShallowRef<Error | null>;
+    clearError: () => void;
+}
+/** Reactive view over caller-owned SIWX session lifecycle and policy state. */
+declare function useSIWxSession(options: UseSIWxSessionOptions): UseSIWxSessionReturn;
+
+interface UseSiwxAuthSessionOptions {
+    result: MaybeRefOrGetter<SiwxResult | null>;
+    isRestoring: MaybeRefOrGetter<boolean>;
+    signIn: MaybeRef<SiwxSignInAction>;
+    signOut: MaybeRef<() => Promise<void>>;
+}
+interface UseSiwxAuthSessionReturn {
+    isSignedIn: ComputedRef<boolean>;
+    isRestoring: ComputedRef<boolean>;
+    siwxResult: ComputedRef<SiwxResult | null>;
+    isSigningIn: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    signIn: SiwxSignInAction;
+    signOut: () => Promise<void>;
+    clearError: () => void;
+}
+/** Reactive auth view over caller-owned, already-validated SIWX persistence. */
+declare function useSiwxAuthSession(options: UseSiwxAuthSessionOptions): UseSiwxAuthSessionReturn;
+
+/** Minimal read-only contract; a viem PublicClient satisfies it. */
+interface NativeBalanceReader {
+    getBalance(args: {
+        address: `0x${string}`;
+    }): Promise<bigint>;
+}
+interface UseBalanceOptions {
+    /** Native currency decimals. Default 18. */
+    decimals?: MaybeRefOrGetter<number | null | undefined>;
+    /**
+     * Native currency symbol, or null when it is not known. Null rather than
+     * "ETH": a wrong unit beside the number is worse than no unit.
+     */
+    symbol?: MaybeRefOrGetter<string | null | undefined>;
+    /** Auto-refresh interval in milliseconds. Default: no auto-refresh. */
+    refreshInterval?: MaybeRefOrGetter<number | null | undefined>;
+}
+interface UseBalanceReturn {
+    /** Raw balance in wei as a decimal string, or null when unread. */
+    balance: ShallowRef<string | null>;
+    /** Human-readable balance in the native unit, or null when unread. */
+    formatted: ComputedRef<string | null>;
+    symbol: ComputedRef<string | null>;
+    isFetching: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refetch: () => Promise<void>;
+}
+/**
+ * Native balance of an EVM account through a caller-owned reader.
+ *
+ * Vue has no AppKit provider, so the client is explicit. Unlike the React
+ * hook this does not fetch a USD price: that is an outward HTTP call the
+ * caller did not hand us, and it belongs beside the reader they did.
+ */
+declare function useBalance(account: MaybeRefOrGetter<string | null | undefined>, client: MaybeRefOrGetter<NativeBalanceReader | null | undefined>, options?: UseBalanceOptions): UseBalanceReturn;
+
+interface UseRouteQuoteOptions {
+    /** Debounce before auto-fetching after an input change (default 300 ms). */
+    debounceMs?: number;
+}
+interface UseRouteQuoteReturn {
+    quotes: ShallowRef<RouteQuote[]>;
+    loading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refresh: () => Promise<void>;
+    clear: () => void;
+}
+/**
+ * Debounced cross-chain route quotes through a caller-supplied quote
+ * function, mirroring the React hook. Which inputs are quotable is decided
+ * in appkit-core; this file debounces and drops late results.
+ */
+declare function useRouteQuote(input: MaybeRefOrGetter<RouteQuoteInput>, getQuotes?: MaybeRef<GetRouteQuotes | null | undefined>, options?: UseRouteQuoteOptions): UseRouteQuoteReturn;
+
+interface UseCompareCostsReturn {
+    comparisons: ShallowRef<CostComparison[]>;
+    loading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refresh: () => Promise<void>;
+}
+/**
+ * Compare an operation's cost across chains through a caller-supplied
+ * function, mirroring the React hook. Re-fetches when the input's *value*
+ * changes (appkit-core's `compareCostsKey`), not when a new array or object
+ * with the same content is passed; only the newest request may write.
+ */
+declare function useCompareCosts(input: MaybeRefOrGetter<CompareCostsInput>, compareCosts?: MaybeRef<CompareCosts | null | undefined>): UseCompareCostsReturn;
+
+interface UseExecuteRouteReturn {
+    execute: (quote: ExecutableQuote, recipient: string, options?: ExecuteRouteOptions) => Promise<ExecuteRouteResult | null>;
+    executing: ShallowRef<boolean>;
+    result: ShallowRef<ExecuteRouteResult | null>;
+    error: ShallowRef<ExecuteRouteError | null>;
+    reset: () => void;
+}
+/**
+ * Execute a quoted route once through a caller-supplied executor, mirroring
+ * the React hook. The recipient check and error shape are appkit-core's. A
+ * second call while one is in flight is refused, and `reset()` deliberately
+ * does not unlock that guard: the first request is still out there.
+ */
+declare function useExecuteRoute(executeRoute?: MaybeRef<ExecuteRoute | null | undefined>): UseExecuteRouteReturn;
+
+interface UseTokenListOptions {
+    /** Load on creation (default: true). */
+    autoLoad?: boolean;
+    /** Custom sources; the manager's defaults otherwise. */
+    sources?: TokenListSource[];
+    /** Reuse a caller-owned manager instead of creating one. */
+    manager?: TokenListManager;
+}
+interface UseTokenListReturn {
+    /** Tokens for the given chain, or all chains when none is given. */
+    tokens: ShallowRef<TokenListEntry[]>;
+    isLoading: ShallowRef<boolean>;
+    /** True once a load has completed at least once. */
+    isLoaded: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    /** Force a refresh from all sources. */
+    refetch: () => Promise<void>;
+}
+/**
+ * Token list for a chain, mirroring the React hook. The list logic, caching
+ * and chain filtering are `TokenListManager`'s; this file is Vue plumbing.
+ * The chain id is CAIP-2; a non-EVM chain yields the unfiltered list rather
+ * than a bogus numeric filter.
+ */
+declare function useTokenList(chainId?: MaybeRefOrGetter<string | null | undefined>, options?: UseTokenListOptions): UseTokenListReturn;
+
+interface UseTokenSearchOptions {
+    /** Reuse a caller-owned manager; otherwise one shared instance per page. */
+    manager?: TokenListManager;
+    /** Debounce in ms (default 300). */
+    debounceMs?: number;
+    /** Max results per bucket (default 20). */
+    limit?: number;
+}
+interface UseTokenSearchReturn {
+    results: ShallowRef<TokenSearchResult>;
+    /** True from the first keystroke until the debounced search has run. */
+    isSearching: ShallowRef<boolean>;
+}
+/**
+ * Debounced token search by symbol, name or address, mirroring the React
+ * hook. Matching lives in `TokenListManager.search`; this file only debounces
+ * and keeps a late timer from writing after the query moved on.
+ */
+declare function useTokenSearch(query: MaybeRefOrGetter<string | null | undefined>, chainId?: MaybeRefOrGetter<string | null | undefined>, options?: UseTokenSearchOptions): UseTokenSearchReturn;
+
+interface UseValidateDestinationReturn {
+    validation: ComputedRef<DestinationValidation>;
+}
+/**
+ * Syntactic destination checks, shared with the React hook through
+ * `@naculus/connect-appkit-core`. Returns a machine-readable `issue`; the
+ * Vue package carries no locale table, so the caller maps it to a string.
+ * `level: "ok"` means nothing wrong was found — not that it is safe.
+ */
+declare function useValidateDestination(address: MaybeRefOrGetter<string | null | undefined>): UseValidateDestinationReturn;
+
+interface TokenInfo {
+    /** ERC-20 token contract address */
+    address: `0x${string}`;
+    symbol: string;
+    decimals: number;
+    name?: string;
+}
+/** Minimal read-only contract; a viem PublicClient satisfies it. */
+interface TokenBalanceReader {
+    readContract(args: {
+        address: `0x${string}`;
+        abi: typeof ERC20_MIN_ABI;
+        functionName: "balanceOf";
+        args: readonly [`0x${string}`];
+    }): Promise<unknown>;
+}
+interface TokenBalanceResult extends TokenInfo {
+    /** Raw balance in the smallest unit as a decimal string, or null if unread. */
+    balance: string | null;
+    /** Human-readable balance, or null if unread. */
+    formatted: string | null;
+}
+interface UseTokenBalanceOptions {
+    /** Auto-refresh interval in milliseconds. Default: no auto-refresh. */
+    refreshInterval?: MaybeRefOrGetter<number | null | undefined>;
+}
+interface UseTokenBalanceReturn {
+    tokenBalances: ShallowRef<TokenBalanceResult[]>;
+    isFetching: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refetch: () => Promise<void>;
+    getTokenBalance: (tokenAddress: `0x${string}`) => TokenBalanceResult | undefined;
+}
+/**
+ * ERC-20 balances of an EVM account through a caller-owned reader.
+ *
+ * Mirrors the React hook: one token failing to read leaves that entry with a
+ * null balance and does not fail the others. A late response for a previous
+ * account, reader or token list is dropped.
+ */
+declare function useTokenBalance(account: MaybeRefOrGetter<string | null | undefined>, client: MaybeRefOrGetter<TokenBalanceReader | null | undefined>, tokens: MaybeRefOrGetter<readonly TokenInfo[] | null | undefined>, options?: UseTokenBalanceOptions): UseTokenBalanceReturn;
+
+/** Minimal read-only contract; a viem PublicClient can supply getCode. */
+interface DelegationCodeReader {
+    getCode(args: {
+        address: `0x${string}`;
+    }): Promise<`0x${string}` | undefined>;
+}
+interface UseDelegationReturn {
+    delegated: ComputedRef<boolean | null>;
+    delegate: ComputedRef<`0x${string}` | null>;
+    isFetching: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refetch: () => Promise<void>;
+}
+/** Read current EIP-7702 delegation without treating an unread account as undelegated. */
+declare function useDelegation(account: MaybeRefOrGetter<string | null | undefined>, client: MaybeRefOrGetter<DelegationCodeReader | null | undefined>, chainId?: MaybeRefOrGetter<string | null | undefined>): UseDelegationReturn;
+
+interface NameLookupReturn<T> {
+    data: ShallowRef<T | null>;
+    isLoading: ComputedRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refetch: () => void;
+}
+
+type UseResolveNameReturn = NameLookupReturn<AddressResult>;
+/** Resolve a reactive ENS or SNS name to an address. */
+declare function useResolveName(name: MaybeRefOrGetter<string>, options?: {
+    skip?: MaybeRefOrGetter<boolean | undefined>;
+    resolverConfig?: MaybeRefOrGetter<NameResolverConfig | undefined>;
+}): UseResolveNameReturn;
+
+type UseLookupAddressReturn = NameLookupReturn<NameResult>;
+/** Reverse-resolve a reactive address, optionally scoped to a CAIP-2 chain. */
+declare function useLookupAddress(address: MaybeRefOrGetter<string>, options?: {
+    chainId?: MaybeRefOrGetter<string | undefined>;
+    skip?: MaybeRefOrGetter<boolean | undefined>;
+    resolverConfig?: MaybeRefOrGetter<NameResolverConfig | undefined>;
+}): UseLookupAddressReturn;
+
+interface UseSolanaAccountReturn {
+    address: ComputedRef<string | null>;
+    caip10: ComputedRef<string | null>;
+    chainId: ComputedRef<string | null>;
+    isConnected: ComputedRef<boolean>;
+}
+/** Read the connected Solana CAIP-10 account from any wallet. */
+declare function useSolanaAccount(accounts: MaybeRefOrGetter<string[] | null | undefined>, connected: MaybeRefOrGetter<boolean>): UseSolanaAccountReturn;
+
 interface UseChainReturn {
     /** The configured chain matching the connected CAIP-2 id, or null. */
     currentChain: ComputedRef<WalletChain | null>;
@@ -133,6 +1009,81 @@ interface UseSolanaBalanceReturn {
  */
 declare function useSolanaBalance(address: MaybeRefOrGetter<string | null | undefined>, rpcUrl: MaybeRefOrGetter<string | null | undefined>): UseSolanaBalanceReturn;
 
+type TxStatus = "pending" | "mined" | "confirmed" | "failed" | "unknown";
+interface TxStatusEntry {
+    hash: string;
+    chainId: number;
+    from: string;
+    to: string;
+    value: string;
+    data?: string;
+    nonce?: number;
+    status: TxStatus;
+    blockNumber?: number;
+    blockHash?: string;
+    gasUsed?: string;
+    effectiveGasPrice?: string;
+    createdAt: number;
+    confirmedAt?: number;
+    updatedAt: number;
+    error?: string;
+    label?: string;
+    memo?: string;
+    replacementCount?: number;
+}
+/** Structural contract accepted by the transaction-monitor composables. */
+interface TxMonitorLike {
+    watchTx(hash: string, chainId: number, options?: Record<string, unknown>): Promise<TxStatusEntry>;
+    stopWatching(hash: string, chainId?: number): void;
+    getTxStatus(hash: string, chainId?: number): TxStatusEntry | null;
+    getTxHistory(address?: string, chainId?: number): Promise<TxStatusEntry[]>;
+    refreshTx(hash: string, chainId?: number): Promise<void>;
+    on(event: "statusChange", listener: (entry: TxStatusEntry) => void): this;
+    on(event: "confirmed", listener: (entry: TxStatusEntry) => void): this;
+    on(event: "failed", listener: (entry: TxStatusEntry) => void): this;
+    off(event: string, listener: Function): this;
+}
+interface UseTxMonitorReturn {
+    entry: ShallowRef<TxStatusEntry | null>;
+    status: ComputedRef<TxStatus | "idle">;
+    isLoading: ShallowRef<boolean>;
+    isWatching: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refresh: () => Promise<void>;
+    stopWatching: () => void;
+}
+/**
+ * Reactively monitor one transaction using a caller-owned TxMonitor.
+ *
+ * Vue has no AppKit monitor provider, so the monitor is explicit. The hook
+ * listens only while its source values are current; a late promise from a
+ * previous hash, chain, or monitor cannot overwrite the active result.
+ */
+declare function useTxMonitor(hash: MaybeRefOrGetter<string | null | undefined>, chainId: MaybeRefOrGetter<number | null | undefined>, monitor: MaybeRefOrGetter<TxMonitorLike | null | undefined>): UseTxMonitorReturn;
+
+interface UseLastTxReturn {
+    lastTx: ShallowRef<TxStatusEntry | null>;
+    lastConfirmedTx: ShallowRef<TxStatusEntry | null>;
+    lastFailedTx: ShallowRef<TxStatusEntry | null>;
+    clear: () => void;
+}
+/** Track the latest confirmed or failed transaction from a caller-owned monitor. */
+declare function useLastTx(monitor: MaybeRefOrGetter<TxMonitorLike | null | undefined>): UseLastTxReturn;
+
+interface UseTxHistoryReturn {
+    entries: ShallowRef<TxStatusEntry[]>;
+    isLoading: ShallowRef<boolean>;
+    error: ShallowRef<Error | null>;
+    refresh: () => Promise<void>;
+    summary: ComputedRef<{
+        pending: number;
+        confirmed: number;
+        failed: number;
+    }>;
+}
+/** Query and keep a caller-owned monitor's transaction history current. */
+declare function useTxHistory(address: MaybeRefOrGetter<string | null | undefined>, chainId: MaybeRefOrGetter<number | null | undefined>, monitor: MaybeRefOrGetter<TxMonitorLike | null | undefined>): UseTxHistoryReturn;
+
 /** The part of a connector this needs. Anything with these two is enough. */
 interface CapabilityClient {
     getCapabilities?: (session: unknown) => Promise<Record<string, unknown>>;
@@ -199,4 +1150,4 @@ declare function useSolanaRoles(connector: MaybeRefOrGetter<SolanaRolesSource |
     walletType?: string;
 } | null | undefined>): UseSolanaRolesReturn;
 
-export { type AccountEntry, AppkitAccordion, AppkitAccountButton, AppkitAlertDialog, AppkitAvatar, AppkitBadge, AppkitButton, AppkitCard, AppkitCardContent, AppkitCardDescription, AppkitCardFooter, AppkitCardHeader, AppkitCardTitle, AppkitCheckbox, AppkitCollapsible, AppkitConnectButton, AppkitDialog, AppkitDropdownMenu, AppkitInput, AppkitPopover, AppkitProgress, AppkitScrollArea, AppkitSelect, AppkitSeparator, AppkitSkeleton, AppkitSwitch, AppkitTabs, AppkitToggleGroup, AppkitTooltip, type CapabilityClient, type UseAccountsReturn, type UseCapabilitiesReturn, type UseChainReturn, type UsePassphraseGateReturn, type UseSolanaBalanceReturn as UseSolanaBalanceVueReturn, type UseSolanaRolesReturn, useAccounts, useCapabilities, useChain, usePassphraseGate, useSolanaBalance, useSolanaRoles };
+export { type AccountEntry, AppkitAccordion, AppkitAccountButton, AppkitAlertDialog, AppkitAvatar, AppkitBadge, AppkitButton, AppkitCard, AppkitCardContent, AppkitCardDescription, AppkitCardFooter, AppkitCardHeader, AppkitCardTitle, AppkitCheckbox, AppkitCollapsible, AppkitConnectButton, AppkitDialog, AppkitDropdownMenu, AppkitInput, AppkitPopover, AppkitProgress, AppkitScrollArea, AppkitSelect, AppkitSeparator, AppkitSkeleton, AppkitSwitch, AppkitTabs, AppkitToggleGroup, AppkitTooltip, type CapabilityClient, type DelegationCodeReader, type DeployTransactionSender, type ERC20Reader, type ERC20Sender, type ERC20Transaction, type EmbeddedWalletAccountView, type EmbeddedWalletView, type EvmTransaction, type ExecuteCallsAction, type ExecutionPreview, type ExecutionRoute, type GetCallsStatusAction, type GetSolanaTransactionStatusAction, type NativeBalanceReader, type PaymasterService, type PreviewExecutionAction, type SendCallsAction, type SendCallsOptions, type SendCallsStatus, type SendSolanaTransactionAction, type SendTransactionAction, type SendTransactionStatus, type SessionKeyComposableOptions, type ShowCallsStatusAction, type SignMessageAction, type SignSolanaTransactionAction, type SiwxResult, type SiwxSessionLike, type SiwxSignInAction, type SiwxSignInOptions, type SolanaTransaction, type TokenBalanceReader, type TokenBalanceResult, type TokenInfo, type TxMonitorLike, type TxStatus, type TxStatusEntry, type UseAccountReturn, type UseAccountsReturn, type UseBalanceOptions, type UseBalanceReturn, type UseCapabilitiesReturn, type UseChainReturn, type UseCompareCostsReturn, type UseConnectReturn, type UseCreateSessionKeyReturn, type UseDelegationPolicyOptions, type UseDelegationPolicyReturn, type UseDelegationReturn, type UseDisconnectReturn, type UseERC20ApproveOptions, type UseERC20ApproveReturn, type UseERC20TransferOptions, type UseERC20TransferReturn, type UseERC20TransferSimulationOptions, type UseERC20TransferSimulationReturn, type UseEmbeddedWalletOptions, type UseEmbeddedWalletReturn, type UseExecuteCallsOptions, type UseExecuteCallsReturn, type UseExecuteRouteReturn, type UseLastTxReturn, type UseLookupAddressReturn, type UseNotificationOptions, type UseNotificationReturn, type UsePassphraseGateReturn, type UseResolveNameReturn, type UseRevokeSessionReturn, type UseRouteQuoteOptions, type UseRouteQuoteReturn, type UseSIWxLoginReturn, type UseSIWxSessionOptions, type UseSIWxSessionReturn, type UseSendCallsOptions, type UseSendCallsReturn, type UseSendTransactionReturn, type UseSendUserOperationOptions, type UseSendUserOperationReturn, type UseSendWithSessionReturn, type UseSessionKeysReturn, type UseSessionReturn, type UseSignInWithEthereumOptions, type UseSignInWithEthereumReturn, type UseSignInWithXReturn, type UseSignMessageReturn, type UseSimulateTransferOptions, type UseSimulateTransferReturn, type UseSiwxAuthSessionOptions, type UseSiwxAuthSessionReturn, type UseSmartAccountOptions, type UseSmartAccountReturn, type UseSolanaAccountReturn, type UseSolanaBalanceReturn as UseSolanaBalanceVueReturn, type UseSolanaRolesReturn, type UseSolanaTransactionOptions, type UseSolanaTransactionReturn, type UseSwitchChainReturn, type UseTokenBalanceOptions, type UseTokenBalanceReturn, type UseTokenListOptions, type UseTokenListReturn, type UseTokenSearchOptions, type UseTokenSearchReturn, type UseTransactionSimulationOptions, type UseTransactionSimulationReturn, type UseTxHistoryReturn, type UseTxMonitorReturn, type UseUserOpStatusOptions, type UseUserOpStatusReturn, type UseValidateDestinationReturn, type UserOpSigner, type UserOpStatus, useAccount, useAccounts, useBalance, useCapabilities, useChain, useCompareCosts, useConnect, useCreateSessionKey, useDelegation, useDelegationPolicy, useDisconnect, useERC20Approve, useERC20Transfer, useERC20TransferSimulation, useEmbeddedWallet, useExecuteCalls, useExecuteRoute, useLastTx, useLookupAddress, useNotification, usePassphraseGate, useResolveName, useRevokeSession, useRouteQuote, useSIWxLogin, useSIWxSession, useSendCalls, useSendTransaction, useSendUserOperation, useSendWithSession, useSession, useSessionKeys, useSignInWithEthereum, useSignInWithX, useSignMessage, useSimulateTransfer, useSiwxAuthSession, useSmartAccount, useSolanaAccount, useSolanaBalance, useSolanaRoles, useSolanaTransaction, useSwitchChain, useTokenBalance, useTokenList, useTokenSearch, useTransactionSimulation, useTxHistory, useTxMonitor, useUserOpStatus, useValidateDestination };