@satoshai/kit 0.5.0 → 0.6.0

package/README.md

@@ -1,5 +1,9 @@
 # @satoshai/kit
 
+[![npm version](https://img.shields.io/npm/v/@satoshai/kit)](https://www.npmjs.com/package/@satoshai/kit)
+[![CI](https://github.com/satoshai-dev/kit/actions/workflows/ci.yml/badge.svg)](https://github.com/satoshai-dev/kit/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
 Typesafe Stacks wallet & contract interaction library for React. Wagmi-inspired hook API for connecting wallets, signing messages, and calling contracts on the Stacks blockchain.
 
 ## Features
@@ -9,6 +13,8 @@ Typesafe Stacks wallet & contract interaction library for React. Wagmi-inspired
 - **`useWallets`** — Configured wallets with availability status
 - **`useAddress`** — Access connected wallet address and status
 - **`useSignMessage`** — Sign arbitrary messages
+- **`useSignStructuredMessage`** — Sign SIP-018 structured data
+- **`useSignTransaction`** — Sign serialized transactions (sponsored tx flows)
 - **`useWriteContract`** — Call smart contracts with post-conditions
 - **`useTransferSTX`** — Native STX transfers
 - **`useBnsName`** — Resolve BNS v2 names
@@ -180,6 +186,40 @@ signMessage({ message: 'Hello Stacks' }, {
 const { publicKey, signature } = await signMessageAsync({ message: 'Hello Stacks' });
 ```
 
+### `useSignStructuredMessage()`
+
+Sign SIP-018 structured data for typed, verifiable off-chain messages.
+
+> **Note:** OKX wallet does not support structured message signing and will throw an error.
+
+```ts
+import { tupleCV, stringAsciiCV, uintCV } from '@stacks/transactions';
+
+const { signStructuredMessage, signStructuredMessageAsync, data, error, isPending } = useSignStructuredMessage();
+
+// Callback style
+signStructuredMessage({
+  domain: tupleCV({
+    name: stringAsciiCV('MyApp'),
+    version: stringAsciiCV('1.0'),
+    'chain-id': uintCV(1),
+  }),
+  message: tupleCV({
+    action: stringAsciiCV('authorize'),
+    amount: uintCV(1000),
+  }),
+}, {
+  onSuccess: ({ publicKey, signature }) => {},
+  onError: (error) => {},
+});
+
+// Async style
+const { publicKey, signature } = await signStructuredMessageAsync({
+  domain: tupleCV({ ... }),
+  message: tupleCV({ ... }),
+});
+```
+
 ### `useTransferSTX()`
 
 ```ts
@@ -224,6 +264,28 @@ writeContract({
 });
 ```
 
+### `useSignTransaction()`
+
+Sign a serialized transaction without automatically broadcasting it. Useful for sponsored transaction flows where a separate service pays the fee.
+
+> **Note:** OKX wallet does not support raw transaction signing and will throw an error.
+
+```ts
+const { signTransaction, signTransactionAsync, data, error, isPending } = useSignTransaction();
+
+// Callback style
+signTransaction({ transaction: '0x0100...', broadcast: false }, {
+  onSuccess: ({ transaction, txid }) => {},
+  onError: (error) => {},
+});
+
+// Async style
+const { transaction, txid } = await signTransactionAsync({
+  transaction: '0x0100...',
+  broadcast: false,
+});
+```
+
 ### `useBnsName()`
 
 ```ts

package/dist/index.cjs

@@ -752,6 +752,153 @@ var useSignMessage = () => {
     [signMessage, signMessageAsync, reset, data, error, status]
   );
 };
+var useSignStructuredMessage = () => {
+  const { isConnected, provider } = useAddress();
+  const [data, setData] = react.useState(
+    void 0
+  );
+  const [error, setError] = react.useState(null);
+  const [status, setStatus] = react.useState("idle");
+  const signStructuredMessageAsync = react.useCallback(
+    async (variables) => {
+      if (!isConnected) {
+        throw new Error("Wallet is not connected");
+      }
+      if (provider === "okx") {
+        throw new Error(
+          "Structured message signing is not supported by OKX wallet"
+        );
+      }
+      setStatus("pending");
+      setError(null);
+      setData(void 0);
+      try {
+        const result = await connect.request("stx_signStructuredMessage", {
+          message: variables.message,
+          domain: variables.domain
+        });
+        setData(result);
+        setStatus("success");
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [isConnected, provider]
+  );
+  const signStructuredMessage = react.useCallback(
+    (variables, options) => {
+      signStructuredMessageAsync(variables).then((data2) => {
+        options?.onSuccess?.(data2);
+        options?.onSettled?.(data2, null);
+      }).catch((error2) => {
+        options?.onError?.(error2);
+        options?.onSettled?.(void 0, error2);
+      });
+    },
+    [signStructuredMessageAsync]
+  );
+  const reset = react.useCallback(() => {
+    setData(void 0);
+    setError(null);
+    setStatus("idle");
+  }, []);
+  return react.useMemo(
+    () => ({
+      signStructuredMessage,
+      signStructuredMessageAsync,
+      reset,
+      data,
+      error,
+      isError: status === "error",
+      isIdle: status === "idle",
+      isPending: status === "pending",
+      isSuccess: status === "success",
+      status
+    }),
+    [
+      signStructuredMessage,
+      signStructuredMessageAsync,
+      reset,
+      data,
+      error,
+      status
+    ]
+  );
+};
+var useSignTransaction = () => {
+  const { isConnected, provider } = useAddress();
+  const [data, setData] = react.useState(void 0);
+  const [error, setError] = react.useState(null);
+  const [status, setStatus] = react.useState("idle");
+  const signTransactionAsync = react.useCallback(
+    async (variables) => {
+      if (!isConnected) {
+        throw new Error("Wallet is not connected");
+      }
+      if (provider === "okx") {
+        throw new Error(
+          "Transaction signing is not supported by OKX wallet"
+        );
+      }
+      setStatus("pending");
+      setError(null);
+      setData(void 0);
+      try {
+        const result = await connect.request("stx_signTransaction", {
+          transaction: variables.transaction,
+          ...variables.broadcast !== void 0 && {
+            broadcast: variables.broadcast
+          }
+        });
+        setData(result);
+        setStatus("success");
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [isConnected, provider]
+  );
+  const signTransaction = react.useCallback(
+    (variables, options) => {
+      signTransactionAsync(variables).then((data2) => {
+        options?.onSuccess?.(data2);
+        options?.onSettled?.(data2, null);
+      }).catch((error2) => {
+        options?.onError?.(error2);
+        options?.onSettled?.(void 0, error2);
+      });
+    },
+    [signTransactionAsync]
+  );
+  const reset = react.useCallback(() => {
+    setData(void 0);
+    setError(null);
+    setStatus("idle");
+  }, []);
+  return react.useMemo(
+    () => ({
+      signTransaction,
+      signTransactionAsync,
+      reset,
+      data,
+      error,
+      isError: status === "error",
+      isIdle: status === "idle",
+      isPending: status === "pending",
+      isSuccess: status === "success",
+      status
+    }),
+    [signTransaction, signTransactionAsync, reset, data, error, status]
+  );
+};
 
 // src/utils/get-network-from-address.ts
 var getNetworkFromAddress = (address) => {
@@ -1144,6 +1291,8 @@ exports.useBnsName = useBnsName;
 exports.useConnect = useConnect;
 exports.useDisconnect = useDisconnect;
 exports.useSignMessage = useSignMessage;
+exports.useSignStructuredMessage = useSignStructuredMessage;
+exports.useSignTransaction = useSignTransaction;
 exports.useTransferSTX = useTransferSTX;
 exports.useWallets = useWallets;
 exports.useWriteContract = useWriteContract;