@rialo/frost 0.1.0 → 0.1.1

package/README.md

@@ -38,6 +38,7 @@ That's it. You now have a working wallet connection button.
 - [Installation](#installation)
 - [Step-by-Step Guide](#step-by-step-guide)
 - [Hooks Reference](#hooks-reference)
+- [Async/Await with mutateAsync](#asyncawait-with-mutateasync)
 - [Components](#components)
 - [Error Handling](#error-handling)
 - [Advanced Usage](#advanced-usage)
@@ -322,13 +323,118 @@ function SendTx({ transaction }: { transaction: Uint8Array }) {
 | Hook | Description |
 |------|-------------|
 | `useSignMessage()` | Sign arbitrary messages |
-| `useSignIn()` | Sign-In with Wallet (SIWS authentication) |
 | `useSignTransaction()` | Sign transaction without sending |
 | `useSendTransaction()` | Sign and send via wallet |
 | `useSignAndSendTransaction()` | Sign via wallet, send via Frost's RPC |
 
 ---
 
+## Async/Await with mutateAsync
+
+All mutation hooks (`useConnectWallet`, `useSignMessage`, `useSignTransaction`, `useSendTransaction`, `useSignAndSendTransaction`, `useDisconnectWallet`, `useSwitchChain`) return both `mutate` and `mutateAsync`.
+
+### Callback Pattern (mutate)
+
+The `mutate` function is fire-and-forget with callbacks:
+
+```tsx
+const { mutate: send } = useSendTransaction({
+  onSuccess: (result) => console.log("Sent:", result.signature),
+  onError: (error) => console.error("Failed:", error),
+});
+
+// Fire and forget - no await, no return value
+send({ transaction });
+```
+
+### Async/Await Pattern (mutateAsync)
+
+The `mutateAsync` function returns a Promise you can await:
+
+```tsx
+const { mutateAsync: sendAsync } = useSendTransaction();
+
+async function handleSend() {
+  try {
+    const result = await sendAsync({ transaction });
+    console.log("Transaction signature:", result.signature);
+    // Continue with next steps...
+  } catch (error) {
+    console.error("Transaction failed:", error);
+  }
+}
+```
+
+### When to Use Each
+
+| Pattern | Use When |
+|---------|----------|
+| `mutate` | Simple fire-and-forget, UI updates via hook state |
+| `mutateAsync` | Sequential operations, custom error handling, chaining actions |
+
+### Real-World Example: Sign Then Send
+
+```tsx
+function TransactionFlow() {
+  const { mutateAsync: signAsync } = useSignTransaction();
+  const { mutateAsync: sendAsync } = useSendTransaction();
+  const [status, setStatus] = useState<string>("");
+
+  async function handleTransaction(transaction: Uint8Array) {
+    try {
+      setStatus("Signing...");
+      const { signedTransaction } = await signAsync({ transaction });
+
+      setStatus("Sending...");
+      const { signature } = await sendAsync({ transaction: signedTransaction });
+
+      setStatus(`Success! Signature: ${signature}`);
+    } catch (error) {
+      setStatus(`Error: ${error.message}`);
+    }
+  }
+
+  return (
+    <div>
+      <button onClick={() => handleTransaction(myTx)}>Execute</button>
+      <p>{status}</p>
+    </div>
+  );
+}
+```
+
+### All Mutation Hooks Support Both Patterns
+
+```tsx
+// Connection
+const { mutateAsync: connectAsync } = useConnectWallet();
+const result = await connectAsync({ walletName: "Rialo" });
+
+// Signing
+const { mutateAsync: signMessageAsync } = useSignMessage();
+const { signature } = await signMessageAsync({ message: "Hello" });
+
+// Transactions
+const { mutateAsync: signTxAsync } = useSignTransaction();
+const { signedTransaction } = await signTxAsync({ transaction });
+
+const { mutateAsync: sendTxAsync } = useSendTransaction();
+const { signature } = await sendTxAsync({ transaction });
+
+const { mutateAsync: signAndSendAsync } = useSignAndSendTransaction();
+const { signature } = await signAndSendAsync({ transaction });
+
+// Disconnect
+const { mutateAsync: disconnectAsync } = useDisconnectWallet();
+await disconnectAsync();
+
+// Switch chain
+const { mutateAsync: switchChainAsync } = useSwitchChain();
+await switchChainAsync(getDefaultRialoClientConfig("mainnet"));
+```
+
+---
+
 ## Hooks in Detail
 
 ### useConnectWallet
@@ -371,33 +477,6 @@ signMessage({ message: "Hello World" });
 signMessage({ message: new Uint8Array([1, 2, 3]) });
 ```
 
-### useSignIn
-
-SIWS (Sign-In with Wallet) for authentication:
-
-```tsx
-const { mutate: signIn } = useSignIn({
-  onSuccess: async (result) => {
-    // Send to your backend for verification
-    await fetch("/api/auth", {
-      method: "POST",
-      body: JSON.stringify({
-        signature: Array.from(result.signature),
-        message: Array.from(result.signedMessage),
-        address: result.account.address,
-      }),
-    });
-  },
-});
-
-signIn({
-  domain: window.location.host,
-  statement: "Sign in to MyApp",
-  nonce: crypto.randomUUID(),
-  expirationTime: new Date(Date.now() + 3600000).toISOString(),
-});
-```
-
 ### useNativeBalance
 
 ```tsx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rialo/frost",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "React wallet integration library for Rialo DApps",
   "keywords": [
     "rialo",
@@ -42,10 +42,10 @@
     "react": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
-    "@rialo/ts-cdk": "0.1.5",
+    "@rialo/ts-cdk": "0.1.9",
     "@tanstack/react-query": "5.90.10",
     "@tanstack/react-store": "0.8.0",
-    "@rialo/frost-core": "^0.1.0"
+    "@rialo/frost-core": "^0.1.1"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "6.9.1",