@volr/react 0.1.99 → 0.1.101

package/README.md

@@ -29,28 +29,34 @@ function App() {
 }
 
 function YourApp() {
-  const { evm, evmAddress, isLoggedIn, logout } = useVolr();
+  const { evm, isLoggedIn, logout } = useVolr();
 
   if (!isLoggedIn) {
     return <div>Please login</div>;
   }
 
-  // Read contract
-  const balance = await evm(8453).readContract({
+  // Get wallet address
+  const address = evm.address;
+
+  // Sign a message (chain-agnostic)
+  const signature = await evm.signMessage('Hello, World!');
+
+  // Read contract (chain-specific)
+  const balance = await evm.client(8453).readContract({
     address: '0x...',
     abi: erc20Abi,
     functionName: 'balanceOf',
-    args: [evmAddress],
+    args: [address],
   });
 
-  // Send transaction
-  const result = await evm(8453).sendTransaction({
+  // Send transaction (chain-specific)
+  const result = await evm.client(8453).sendTransaction({
     to: '0x...',
     data: '0x...',
   });
 
-  // Send batch
-  const result = await evm(8453).sendBatch([
+  // Send batch (chain-specific)
+  const result = await evm.client(8453).sendBatch([
     {
       target: '0x...',
       abi: erc20Abi,
@@ -69,8 +75,8 @@ Main hook for wallet operations.
 
 ```tsx
 const {
-  evm,        // (chainId: number) => EvmClient
-  evmAddress, // `0x${string}` | undefined
+  evm,        // EvmNamespace (see below)
+  evmAddress, // `0x${string}` | undefined (deprecated, use evm.address)
   email,      // string | undefined
   isLoggedIn, // boolean
   signerType, // 'passkey' | 'external_wallet' | 'mpc' | undefined
@@ -80,12 +86,26 @@ const {
 } = useVolr();
 ```
 
-### EvmClient
+### EvmNamespace
 
-Returned by `evm(chainId)`.
+The `evm` object provides chain-agnostic operations and a `client()` method for chain-specific operations.
 
 ```tsx
-const client = evm(8453);
+// Chain-agnostic operations
+evm.address                    // `0x${string}` | undefined
+await evm.signMessage('Hello') // Sign message (EIP-191)
+await evm.signTypedData({...}) // Sign typed data (EIP-712)
+
+// Chain-specific operations
+const client = evm.client(8453);
+```
+
+### EvmChainClient
+
+Returned by `evm.client(chainId)` for chain-specific operations.
+
+```tsx
+const client = evm.client(8453);
 
 // Read contract
 const balance = await client.readContract({
@@ -95,6 +115,9 @@ const balance = await client.readContract({
   args: [userAddress],
 });
 
+// Get balance
+const ethBalance = await client.getBalance('0x...');
+
 // Send single transaction
 const result = await client.sendTransaction({
   to: '0x...',
@@ -124,6 +147,32 @@ const result = await client.sendBatch([
 ]);
 ```
 
+### Message Signing
+
+Sign messages and typed data without specifying a chain (uses the same private key).
+
+```tsx
+// Sign a simple message
+const signature = await evm.signMessage('Hello, World!');
+
+// Sign raw bytes
+const signature = await evm.signMessage(new Uint8Array([1, 2, 3]));
+
+// Sign EIP-712 typed data
+const signature = await evm.signTypedData({
+  domain: {
+    name: 'MyApp',
+    version: '1',
+    chainId: 1,
+    verifyingContract: '0x...',
+  },
+  types: {
+    Message: [{ name: 'content', type: 'string' }],
+  },
+  message: { content: 'Hello' },
+});
+```
+
 ## Features
 
 - **Simple API**: `useVolr()` provides everything you need

package/dist/index.cjs

@@ -18532,12 +18532,54 @@ function useVolr() {
   const { user, config, provider, setProvider, logout, isLoading, error } = useVolrContext();
   const { precheck } = usePrecheck();
   const { relay } = useRelay();
-  const { client } = useInternalAuth();
+  const { client: apiClient } = useInternalAuth();
   const getRpcUrl = react.useCallback(
-    createGetRpcUrl({ client, rpcOverrides: config.rpcOverrides }),
-    [client, config.rpcOverrides]
+    createGetRpcUrl({ client: apiClient, rpcOverrides: config.rpcOverrides }),
+    [apiClient, config.rpcOverrides]
+  );
+  const signMessage = react.useCallback(
+    async (message) => {
+      if (!provider) {
+        throw new Error(
+          "No wallet provider available. Please log in with a Passkey or MPC wallet to sign messages."
+        );
+      }
+      if (config.onSignRequest) {
+        await config.onSignRequest({ type: "message", message });
+      }
+      await provider.ensureSession({ interactive: true });
+      const messageHash = hashMessage(
+        typeof message === "string" ? message : { raw: message }
+      );
+      const hashBytes = new Uint8Array(32);
+      const hex = messageHash.slice(2);
+      for (let i = 0; i < 32; i++) {
+        hashBytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      }
+      const sig = await provider.signMessage(hashBytes);
+      const v = sig.yParity + 27;
+      const rHex = Array.from(sig.r).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const sHex = Array.from(sig.s).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const vHex = v.toString(16).padStart(2, "0");
+      return `0x${rHex}${sHex}${vHex}`;
+    },
+    [provider, config.onSignRequest]
+  );
+  const signTypedData = react.useCallback(
+    async (typedData) => {
+      if (!provider) {
+        throw new Error(
+          "No wallet provider available. Please log in with a Passkey or MPC wallet to sign typed data."
+        );
+      }
+      if (config.onSignRequest) {
+        await config.onSignRequest({ type: "typedData", typedData });
+      }
+      return provider.signTypedData(typedData);
+    },
+    [provider, config.onSignRequest]
   );
-  const evm = react.useCallback(
+  const createChainClient = react.useCallback(
     (chainId) => {
       if (chainId === 0) {
         throw new Error("chainId cannot be 0");
@@ -18556,12 +18598,12 @@ function useVolr() {
       };
       return {
         getBalance: async (address) => {
-          const { publicClient: client2 } = await ensureRpcClient();
-          return client2.getBalance({ address });
+          const { publicClient: client } = await ensureRpcClient();
+          return client.getBalance({ address });
         },
         readContract: async (args) => {
-          const { publicClient: client2 } = await ensureRpcClient();
-          return client2.readContract(args);
+          const { publicClient: client } = await ensureRpcClient();
+          return client.readContract(args);
         },
         sendTransaction: async (tx, opts = {}) => {
           const { publicClient: publicClient2, extendedRpcClient: rpcClient } = await ensureRpcClient();
@@ -18587,7 +18629,7 @@ function useVolr() {
               rpcClient,
               precheck,
               relay,
-              client,
+              client: apiClient,
               user: user ?? null,
               provider: provider ?? null,
               setProvider
@@ -18621,50 +18663,30 @@ function useVolr() {
               rpcClient,
               precheck,
               relay,
-              client,
+              client: apiClient,
               user: user ?? null,
               provider: provider ?? null,
               setProvider
             }
           });
-        }),
-        signMessage: async (message) => {
-          if (!provider) {
-            throw new Error(
-              "No wallet provider available. Please log in with a Passkey or MPC wallet to sign messages."
-            );
-          }
-          await provider.ensureSession({ interactive: true });
-          const messageHash = hashMessage(
-            typeof message === "string" ? message : { raw: message }
-          );
-          const hashBytes = new Uint8Array(32);
-          const hex = messageHash.slice(2);
-          for (let i = 0; i < 32; i++) {
-            hashBytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-          }
-          const sig = await provider.signMessage(hashBytes);
-          const v = sig.yParity + 27;
-          const rHex = Array.from(sig.r).map((b) => b.toString(16).padStart(2, "0")).join("");
-          const sHex = Array.from(sig.s).map((b) => b.toString(16).padStart(2, "0")).join("");
-          const vHex = v.toString(16).padStart(2, "0");
-          return `0x${rHex}${sHex}${vHex}`;
-        },
-        signTypedData: async (typedData) => {
-          if (!provider) {
-            throw new Error(
-              "No wallet provider available. Please log in with a Passkey or MPC wallet to sign typed data."
-            );
-          }
-          return provider.signTypedData(typedData);
-        }
+        })
       };
     },
-    [user, config, provider, precheck, relay, getRpcUrl, setProvider, client]
+    [user, provider, precheck, relay, getRpcUrl, setProvider, apiClient]
+  );
+  const evm = react.useMemo(
+    () => ({
+      address: user?.evmAddress,
+      signMessage,
+      signTypedData,
+      client: createChainClient
+    }),
+    [user?.evmAddress, signMessage, signTypedData, createChainClient]
   );
   return {
     evm,
     evmAddress: user?.evmAddress,
+    // deprecated, kept for backward compatibility
     email: user?.email,
     isLoggedIn: user !== null,
     signerType: user?.signerType,
@@ -18688,19 +18710,6 @@ function toChecksumAddress(address) {
   }
   return checksummed;
 }
-function detectWalletConnector() {
-  if (typeof window === "undefined" || !window.ethereum) {
-    return void 0;
-  }
-  const provider = window.ethereum;
-  if (provider.info?.rdns) return provider.info.rdns;
-  if (provider.isMetaMask) return "io.metamask";
-  if (provider.isCoinbaseWallet) return "com.coinbase.wallet";
-  if (provider.isRabby) return "io.rabby";
-  if (provider.isZerion) return "io.zerion";
-  if (provider.isBraveWallet) return "com.brave.wallet";
-  return "unknown";
-}
 function useVolrLogin() {
   const { config, setUser } = useVolrContext();
   const { setAccessToken, setRefreshToken, client } = useInternalAuth();
@@ -18710,9 +18719,8 @@ function useVolrLogin() {
       projectId: u.projectId,
       projectName: u.projectName,
       email: u.email,
-      accountId: u.accountId ?? void 0,
+      authWallet: u.authWallet ?? void 0,
       evmAddress: u.evmAddress,
-      authWalletAddress: u.authWalletAddress ?? void 0,
       keyStorageType: u.keyStorageType ?? void 0,
       signerType: u.signerType ?? void 0,
       walletConnector: u.walletConnector ?? void 0,
@@ -18834,11 +18842,11 @@ function useVolrLogin() {
     [client, setAccessToken, setRefreshToken, setUser, toVolrUser]
   );
   const signWithWallet = react.useCallback(
-    async (walletAddress) => {
-      if (typeof window === "undefined" || !window.ethereum) {
+    async (walletAddress, options) => {
+      const ethereum = options?.provider ?? (typeof window !== "undefined" ? window.ethereum : null);
+      if (!ethereum) {
         throw new Error("No Ethereum wallet found. Please install MetaMask or another wallet.");
       }
-      const ethereum = window.ethereum;
       const chainIdHex = await ethereum.request({ method: "eth_chainId" });
       const chainId = parseInt(chainIdHex, 16);
       const nonce = await requestSiweNonce();
@@ -18861,7 +18869,7 @@ Issued At: ${issuedAt}`;
         method: "personal_sign",
         params: [message, walletAddress]
       });
-      const walletConnector = detectWalletConnector();
+      const walletConnector = options?.walletConnector ?? ethereum.info?.rdns ?? "unknown";
       return verifySiweSignature(message, signature, { walletConnector, chainId });
     },
     [requestSiweNonce, verifySiweSignature]
@@ -18928,7 +18936,7 @@ function useVolrAuthCallback(options = {}) {
       projectId: u.projectId,
       projectName: u.projectName,
       email: u.email,
-      accountId: u.accountId ?? void 0,
+      authWallet: u.authWallet ?? void 0,
       evmAddress: u.evmAddress,
       keyStorageType: u.keyStorageType ?? void 0,
       signerType: u.signerType ?? void 0,