@jaw.id/wagmi 0.0.1

package/dist/lib/internal/react.js

@@ -0,0 +1,517 @@
+'use client';
+import { useEffect, useMemo, useRef } from 'react';
+import { useAccount, useChainId, useConfig, useConnectors, } from 'wagmi';
+import { useMutation, useQuery, useQueryClient, skipToken, } from '@tanstack/react-query';
+import { connect, disconnect, grantPermissions, getPermissions, revokePermissions, getAssets, getCapabilities, sign, getCallsHistory, } from './core.js';
+import { getPermissionsQueryKey, getAssetsQueryKey, getCapabilitiesQueryKey, getCallsHistoryQueryKey } from './query.js';
+/**
+ * Hook to connect to the wallet with optional capabilities.
+ *
+ * @example
+ * ```tsx
+ * const { mutate, data, isPending } = useConnect();
+ *
+ * // Basic connect
+ * mutate({ connector: jawWallet({ apiKey: 'xxx' }) });
+ *
+ * // Connect with capabilities (subname issuance)
+ * mutate({
+ *   connector: jawWallet({ apiKey: 'xxx' }),
+ *   capabilities: {
+ *     subnameTextRecords: [
+ *       { key: 'avatar', value: 'https://example.com/avatar.png' },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export function useConnect(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        mutationFn: async (variables) => {
+            return connect(config, variables);
+        },
+        mutationKey: ['connect'],
+    });
+}
+/**
+ * Hook to grant permissions to a spender address.
+ *
+ * @example
+ * ```tsx
+ * const { mutate, data, isPending } = useGrantPermissions();
+ *
+ * mutate({
+ *   expiry: Math.floor(Date.now() / 1000) + 3600, // 1 hour
+ *   spender: '0x...',
+ *   permissions: {
+ *     calls: [{ target: '0x...', functionSignature: 'transfer(address,uint256)' }],
+ *     spends: [{ token: '0x...', allowance: '1000000000000000000', unit: 'hour', multiplier: 1 }],
+ *   },
+ * });
+ * ```
+ */
+export function useGrantPermissions(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        mutationFn: async (variables) => {
+            return grantPermissions(config, variables);
+        },
+        mutationKey: ['grantPermissions'],
+    });
+}
+/**
+ * Hook to revoke a permission by its ID.
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useRevokePermissions();
+ *
+ * mutate({
+ *   id: '0x...', // permission hash
+ * });
+ * ```
+ */
+export function useRevokePermissions(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        mutationFn: async (variables) => {
+            return revokePermissions(config, variables);
+        },
+        mutationKey: ['revokePermissions'],
+    });
+}
+/**
+ * Hook to get the current permissions for an account.
+ * Automatically updates when permissions change.
+ *
+ * @example
+ * ```tsx
+ * const { data: permissions, isLoading } = usePermissions();
+ *
+ * // With specific address (works even when not connected)
+ * const { data } = usePermissions({ address: '0x...' });
+ * ```
+ */
+export function usePermissions(parameters = {}) {
+    const { query = {}, ...rest } = parameters;
+    const config = useConfig(rest);
+    const queryClient = useQueryClient();
+    const chainId = useChainId({ config });
+    const { address: connectedAddress, connector, status } = useAccount({ config });
+    const connectors = useConnectors({ config });
+    // Use account connector if connected, otherwise find JAW connector from available connectors
+    const jawConnector = connectors.find((c) => c.id === 'jaw');
+    const activeConnector = parameters.connector ?? connector ?? jawConnector;
+    // Use explicit address if provided, otherwise fall back to connected address
+    const targetAddress = parameters.address ?? connectedAddress;
+    // Enable query if:
+    // 1. Connected (existing behavior), OR
+    // 2. Explicit address provided AND connector available (disconnected query)
+    const isConnected = status === 'connected' || (status === 'reconnecting' && activeConnector?.getProvider);
+    const canQueryDisconnected = Boolean(targetAddress && activeConnector?.getProvider);
+    const enabled = Boolean((isConnected || canQueryDisconnected) && (query.enabled ?? true));
+    const queryKey = useMemo(() => getPermissionsQueryKey({
+        address: targetAddress,
+        chainId: parameters.chainId ?? chainId,
+        connector: activeConnector,
+    }), [targetAddress, chainId, parameters.chainId, activeConnector]);
+    // Set up event listener for permission changes
+    const providerRef = useRef(undefined);
+    const handlerRef = useRef(undefined);
+    useEffect(() => {
+        if (!activeConnector)
+            return;
+        let mounted = true;
+        void (async () => {
+            const provider = (await activeConnector.getProvider?.());
+            if (!mounted || !provider)
+                return;
+            providerRef.current = provider;
+            const handleMessage = (event) => {
+                if (event.type !== 'permissionsChanged')
+                    return;
+                queryClient.invalidateQueries({ queryKey });
+            };
+            handlerRef.current = handleMessage;
+            provider.on('message', handleMessage);
+        })();
+        return () => {
+            mounted = false;
+            if (providerRef.current && handlerRef.current) {
+                providerRef.current.removeListener?.('message', handlerRef.current);
+            }
+        };
+    }, [activeConnector, queryClient, queryKey]);
+    return useQuery({
+        ...query,
+        enabled,
+        gcTime: 0,
+        queryFn: activeConnector
+            ? async () => {
+                // When connected, use the standard flow
+                if (isConnected) {
+                    return getPermissions(config, {
+                        ...rest,
+                        connector: activeConnector,
+                    });
+                }
+                // When disconnected but have address, make direct provider call
+                const provider = (await activeConnector.getProvider?.());
+                if (!provider)
+                    throw new Error('Provider not available');
+                if (!targetAddress)
+                    throw new Error('Address is required when not connected');
+                return provider.request({
+                    method: 'wallet_getPermissions',
+                    params: [{ address: targetAddress }],
+                });
+            }
+            : skipToken,
+        queryKey,
+        staleTime: Number.POSITIVE_INFINITY,
+    });
+}
+/**
+ * Hook to disconnect from the wallet.
+ *
+ * @example
+ * ```tsx
+ * const { mutate: disconnectWallet, isPending } = useDisconnect();
+ *
+ * // Disconnect active connector
+ * disconnectWallet({});
+ *
+ * // Disconnect specific connector
+ * disconnectWallet({ connector: jawWallet({ apiKey: 'xxx' }) });
+ * ```
+ */
+export function useDisconnect(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        mutationFn: async (variables) => {
+            return disconnect(config, variables);
+        },
+        mutationKey: ['disconnect'],
+    });
+}
+/**
+ * Hook to get the assets for an account.
+ * Automatically updates when assets change.
+ *
+ * @example
+ * ```tsx
+ * const { data: assets, isLoading } = useGetAssets();
+ *
+ * // With specific address (works even when not connected)
+ * const { data } = useGetAssets({ address: '0x...' });
+ *
+ * // With chain filter
+ * const { data } = useGetAssets({ chainFilter: ['0x1', '0xa'] });
+ *
+ * // With asset type filter
+ * const { data } = useGetAssets({ assetTypeFilter: ['erc20'] });
+ * ```
+ */
+export function useGetAssets(parameters = {}) {
+    const { query = {}, ...rest } = parameters;
+    const config = useConfig(rest);
+    const queryClient = useQueryClient();
+    const chainId = useChainId({ config });
+    const { address: connectedAddress, connector, status } = useAccount({ config });
+    const connectors = useConnectors({ config });
+    // Use account connector if connected, otherwise find JAW connector from available connectors
+    const jawConnector = connectors.find((c) => c.id === 'jaw');
+    const activeConnector = parameters.connector ?? connector ?? jawConnector;
+    // Use explicit address if provided, otherwise fall back to connected address
+    const targetAddress = parameters.address ?? connectedAddress;
+    // Enable query if:
+    // 1. Connected (existing behavior), OR
+    // 2. Explicit address provided AND connector available (disconnected query)
+    const isConnected = status === 'connected' || (status === 'reconnecting' && activeConnector?.getProvider);
+    const canQueryDisconnected = Boolean(targetAddress && activeConnector?.getProvider);
+    const enabled = Boolean((isConnected || canQueryDisconnected) && (query.enabled ?? true));
+    const queryKey = useMemo(() => getAssetsQueryKey({
+        address: targetAddress,
+        chainId: parameters.chainId ?? chainId,
+        connector: activeConnector,
+        chainFilter: parameters.chainFilter,
+        assetTypeFilter: parameters.assetTypeFilter,
+        assetFilter: parameters.assetFilter,
+    }), [
+        targetAddress,
+        chainId,
+        parameters.chainId,
+        activeConnector,
+        parameters.chainFilter,
+        parameters.assetTypeFilter,
+        parameters.assetFilter,
+    ]);
+    // Set up event listener for asset changes (e.g., after transactions)
+    const providerRef = useRef(undefined);
+    const handlerRef = useRef(undefined);
+    useEffect(() => {
+        if (!activeConnector)
+            return;
+        let mounted = true;
+        void (async () => {
+            const provider = (await activeConnector.getProvider?.());
+            if (!mounted || !provider)
+                return;
+            providerRef.current = provider;
+            const handleMessage = (event) => {
+                if (event.type !== 'assetsChanged')
+                    return;
+                queryClient.invalidateQueries({ queryKey });
+            };
+            handlerRef.current = handleMessage;
+            provider.on('message', handleMessage);
+        })();
+        return () => {
+            mounted = false;
+            if (providerRef.current && handlerRef.current) {
+                providerRef.current.removeListener?.('message', handlerRef.current);
+            }
+        };
+    }, [activeConnector, queryClient, queryKey]);
+    return useQuery({
+        ...query,
+        enabled,
+        gcTime: 0,
+        queryFn: activeConnector
+            ? async () => {
+                // When connected, use the standard flow
+                if (isConnected) {
+                    return getAssets(config, {
+                        ...rest,
+                        address: targetAddress,
+                        connector: activeConnector,
+                    });
+                }
+                // When disconnected but have address, make direct provider call
+                const provider = (await activeConnector.getProvider?.());
+                if (!provider)
+                    throw new Error('Provider not available');
+                if (!targetAddress)
+                    throw new Error('Address is required when not connected');
+                return provider.request({
+                    method: 'wallet_getAssets',
+                    params: [{
+                            account: targetAddress,
+                            chainFilter: parameters.chainFilter,
+                            assetTypeFilter: parameters.assetTypeFilter,
+                            assetFilter: parameters.assetFilter,
+                        }],
+                });
+            }
+            : skipToken,
+        queryKey,
+        staleTime: 30_000, // Cache for 30 seconds since assets change less frequently
+    });
+}
+/**
+ * Hook to get the wallet capabilities (EIP-5792).
+ * Can be called without a connected account.
+ *
+ * @example
+ * ```tsx
+ * // Get capabilities (uses connected account if available)
+ * const { data: capabilities, isLoading } = useCapabilities();
+ *
+ * // With specific address (works even when not connected)
+ * const { data } = useCapabilities({ address: '0x...' });
+ *
+ * // With chain filter
+ * const { data } = useCapabilities({ chainFilter: ['0x1', '0xa'] });
+ * ```
+ */
+export function useCapabilities(parameters = {}) {
+    const { query = {}, ...rest } = parameters;
+    const config = useConfig(rest);
+    const chainId = useChainId({ config });
+    const { address: connectedAddress, connector, status } = useAccount({ config });
+    const connectors = useConnectors({ config });
+    // Use account connector if connected, otherwise find JAW connector from available connectors
+    const jawConnector = connectors.find((c) => c.id === 'jaw');
+    const activeConnector = parameters.connector ?? connector ?? jawConnector;
+    // Use explicit address if provided, otherwise fall back to connected address
+    const targetAddress = parameters.address ?? connectedAddress;
+    // Enable query if:
+    // 1. Connected (existing behavior), OR
+    // 2. Connector available (can query capabilities without connection)
+    const isConnected = status === 'connected' || (status === 'reconnecting' && activeConnector?.getProvider);
+    const canQueryDisconnected = Boolean(activeConnector?.getProvider);
+    const enabled = Boolean((isConnected || canQueryDisconnected) && (query.enabled ?? true));
+    const queryKey = useMemo(() => getCapabilitiesQueryKey({
+        address: targetAddress,
+        chainId: parameters.chainId ?? chainId,
+        connector: activeConnector,
+        chainFilter: parameters.chainFilter,
+    }), [targetAddress, chainId, parameters.chainId, activeConnector, parameters.chainFilter]);
+    return useQuery({
+        ...query,
+        enabled,
+        gcTime: 0,
+        queryFn: activeConnector
+            ? async () => {
+                // When connected, use the standard flow
+                if (isConnected) {
+                    return getCapabilities(config, {
+                        ...rest,
+                        address: targetAddress,
+                        connector: activeConnector,
+                    });
+                }
+                // When disconnected, make direct provider call
+                const provider = (await activeConnector.getProvider?.());
+                if (!provider)
+                    throw new Error('Provider not available');
+                return provider.request({
+                    method: 'wallet_getCapabilities',
+                    params: [targetAddress, parameters.chainFilter],
+                });
+            }
+            : skipToken,
+        queryKey,
+        staleTime: 60_000, // Cache for 60 seconds since capabilities don't change often
+    });
+}
+/**
+ * Hook to sign messages using the unified wallet_sign method (ERC-7871).
+ * This combines the functionality of useSignMessage and useSignTypedData.
+ *
+ * @example
+ * ```tsx
+ * const { mutate: signMessage, data: signature, isPending } = useSign();
+ *
+ * // Personal sign (EIP-191)
+ * signMessage({
+ *   request: {
+ *     type: '0x45',
+ *     data: { message: 'Hello World' },
+ *   },
+ * });
+ *
+ * // Typed data sign (EIP-712)
+ * signMessage({
+ *   request: {
+ *     type: '0x01',
+ *     data: {
+ *       types: { ... },
+ *       primaryType: 'Mail',
+ *       domain: { ... },
+ *       message: { ... },
+ *     },
+ *   },
+ * });
+ *
+ * // Sign on a specific chain (useful for smart accounts)
+ * signMessage({
+ *   chainId: 8453, // Base
+ *   request: {
+ *     type: '0x45',
+ *     data: { message: 'Hello from Base' },
+ *   },
+ * });
+ * ```
+ */
+export function useSign(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        mutationFn: async (variables) => {
+            return sign(config, variables);
+        },
+        mutationKey: ['sign'],
+    });
+}
+/**
+ * Hook to get the calls history for an account.
+ * Can be called without a connected account if address is provided.
+ *
+ * @example
+ * ```tsx
+ * // Get calls history for connected account
+ * const { data: history, isLoading } = useGetCallsHistory();
+ *
+ * // With specific address (works even when not connected)
+ * const { data } = useGetCallsHistory({ address: '0x...' });
+ *
+ * // With pagination
+ * const { data } = useGetCallsHistory({
+ *   address: '0x...',
+ *   limit: 10,
+ *   sort: 'desc',
+ * });
+ * ```
+ */
+export function useGetCallsHistory(parameters = {}) {
+    const { query = {}, ...rest } = parameters;
+    const config = useConfig(rest);
+    const chainId = useChainId({ config });
+    const { address: connectedAddress, connector, status } = useAccount({ config });
+    const connectors = useConnectors({ config });
+    // Use account connector if connected, otherwise find JAW connector from available connectors
+    const jawConnector = connectors.find((c) => c.id === 'jaw');
+    const activeConnector = parameters.connector ?? connector ?? jawConnector;
+    // Use explicit address if provided, otherwise fall back to connected address
+    const targetAddress = parameters.address ?? connectedAddress;
+    // Enable query if:
+    // 1. Connected (existing behavior), OR
+    // 2. Explicit address provided AND connector available (disconnected query)
+    const isConnected = status === 'connected' || (status === 'reconnecting' && activeConnector?.getProvider);
+    const canQueryDisconnected = Boolean(targetAddress && activeConnector?.getProvider);
+    const enabled = Boolean((isConnected || canQueryDisconnected) && (query.enabled ?? true));
+    const queryKey = useMemo(() => getCallsHistoryQueryKey({
+        address: targetAddress,
+        chainId: parameters.chainId ?? chainId,
+        connector: activeConnector,
+        index: parameters.index,
+        limit: parameters.limit,
+        sort: parameters.sort,
+    }), [targetAddress, chainId, parameters.chainId, activeConnector, parameters.index, parameters.limit, parameters.sort]);
+    return useQuery({
+        ...query,
+        enabled,
+        gcTime: 0,
+        queryFn: activeConnector
+            ? async () => {
+                // When connected, use the standard flow
+                if (isConnected) {
+                    return getCallsHistory(config, {
+                        ...rest,
+                        address: targetAddress,
+                        connector: activeConnector,
+                    });
+                }
+                // When disconnected but have address, make direct provider call
+                const provider = (await activeConnector.getProvider?.());
+                if (!provider)
+                    throw new Error('Provider not available');
+                if (!targetAddress)
+                    throw new Error('Address is required when not connected');
+                return provider.request({
+                    method: 'wallet_getCallsHistory',
+                    params: [{
+                            address: targetAddress,
+                            chainId: parameters.chainId,
+                            index: parameters.index,
+                            limit: parameters.limit,
+                            sort: parameters.sort,
+                        }],
+                });
+            }
+            : skipToken,
+        queryKey,
+        staleTime: 30_000, // Cache for 30 seconds
+    });
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@jaw.id/wagmi",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@jaw-mono/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JustaName-id/jaw-mono.git",
+    "directory": "packages/wagmi"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@jaw.id/core": "0.0.1",
+    "@wagmi/core": "^3.0.0",
+    "tslib": "^2.3.0",
+    "viem": "^2.38.2"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": ">=5.0.0",
+    "react": ">=18.0.0",
+    "wagmi": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0"
+  }
+}