@naculus/connect-appkit-vue 0.2.5 → 0.2.6

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import { StencilVueComponent } from '@stencil/vue-output-target/runtime';
 import { JSX } from '@naculus/connect-appkit-wc';
 import { ComputedRef, MaybeRefOrGetter, MaybeRef, ShallowRef, shallowRef, ref } from 'vue';
-import { NotificationSettingsStorage, RouteQuote, RouteQuoteInput, GetRouteQuotes, CostComparison, CompareCostsInput, CompareCosts, ExecutableQuote, ExecuteRouteOptions, ExecuteRouteResult, ExecuteRouteError, ExecuteRoute, DestinationValidation, WalletChain, ChainInfo, ChainCapabilities, AtomicSupport, SolanaRoles, SolanaRolesAbsence, SolanaIdentity, SolanaSigner, SolanaPayer, SolanaRolesSource } from '@naculus/connect-appkit-core';
+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 { InAppChannel, NotificationItem, NotificationSettings, ActiveSessionBundle, ChainSession, SessionManager, WalletError, TokenListSource, TokenListManager, TokenListEntry, TokenSearchResult, ERC20_MIN_ABI, AddressResult, NameResolverConfig, NameResult, 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>;
@@ -77,6 +77,112 @@ interface UseNotificationReturn {
 /** 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>;
@@ -124,6 +230,479 @@ interface UseSwitchChainReturn {
 /** 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: {
@@ -571,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 DelegationCodeReader, type NativeBalanceReader, 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 UseDelegationReturn, type UseDisconnectReturn, type UseExecuteRouteReturn, type UseLastTxReturn, type UseLookupAddressReturn, type UseNotificationOptions, type UseNotificationReturn, type UsePassphraseGateReturn, type UseResolveNameReturn, type UseRouteQuoteOptions, type UseRouteQuoteReturn, type UseSessionReturn, type UseSolanaAccountReturn, type UseSolanaBalanceReturn as UseSolanaBalanceVueReturn, type UseSolanaRolesReturn, type UseSwitchChainReturn, type UseTokenBalanceOptions, type UseTokenBalanceReturn, type UseTokenListOptions, type UseTokenListReturn, type UseTokenSearchOptions, type UseTokenSearchReturn, type UseTxHistoryReturn, type UseTxMonitorReturn, type UseValidateDestinationReturn, useAccount, useAccounts, useBalance, useCapabilities, useChain, useCompareCosts, useConnect, useDelegation, useDisconnect, useExecuteRoute, useLastTx, useLookupAddress, useNotification, usePassphraseGate, useResolveName, useRouteQuote, useSession, useSolanaAccount, useSolanaBalance, useSolanaRoles, useSwitchChain, useTokenBalance, useTokenList, useTokenSearch, useTxHistory, useTxMonitor, useValidateDestination };
+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 };