@1sat/react 0.0.1

package/dist/ConnectButton.d.ts

@@ -0,0 +1,56 @@
+import type { ReactNode } from 'react';
+export interface ConnectButtonProps {
+    /** Custom class name for the button */
+    className?: string;
+    /** Custom styles for the button */
+    style?: React.CSSProperties;
+    /** Text to show when disconnected */
+    connectLabel?: ReactNode;
+    /** Text to show when connecting */
+    connectingLabel?: ReactNode;
+    /** Text to show when connected (receives address) */
+    connectedLabel?: ReactNode | ((address: string) => ReactNode);
+    /** Called after successful connection */
+    onConnect?: () => void;
+    /** Called after disconnection */
+    onDisconnect?: () => void;
+    /** Called on error */
+    onError?: (error: Error) => void;
+    /** Whether to disconnect on click when connected */
+    disconnectOnClick?: boolean;
+    /** Custom render function for full control */
+    children?: (props: {
+        isConnected: boolean;
+        isConnecting: boolean;
+        address: string | null;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+    }) => ReactNode;
+}
+/**
+ * Ready-to-use connect button component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <ConnectButton />
+ *
+ * // With custom labels
+ * <ConnectButton
+ *   connectLabel="Connect 1Sat"
+ *   connectingLabel="Connecting..."
+ *   connectedLabel={(addr) => `Connected: ${addr}`}
+ * />
+ *
+ * // With custom render
+ * <ConnectButton>
+ *   {({ isConnected, connect, disconnect }) => (
+ *     <button onClick={isConnected ? disconnect : connect}>
+ *       {isConnected ? 'Disconnect' : 'Connect'}
+ *     </button>
+ *   )}
+ * </ConnectButton>
+ * ```
+ */
+export declare function ConnectButton({ className, style, connectLabel, connectingLabel, connectedLabel, onConnect, onDisconnect, onError, disconnectOnClick, children, }: ConnectButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ConnectButton.d.ts.map

package/dist/ConnectButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectButton.d.ts","sourceRoot":"","sources":["../src/ConnectButton.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,MAAM,WAAW,kBAAkB;IAClC,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IAC3B,qCAAqC;IACrC,YAAY,CAAC,EAAE,SAAS,CAAA;IACxB,mCAAmC;IACnC,eAAe,CAAC,EAAE,SAAS,CAAA;IAC3B,qDAAqD;IACrD,cAAc,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,SAAS,CAAC,CAAA;IAC7D,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAA;IACzB,sBAAsB;IACtB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAChC,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAClB,WAAW,EAAE,OAAO,CAAA;QACpB,YAAY,EAAE,OAAO,CAAA;QACrB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;QACtB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;QAC5B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAC/B,KAAK,SAAS,CAAA;CACf;AAUD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,EAC7B,SAAS,EACT,KAAK,EACL,YAA+B,EAC/B,eAAiC,EACjC,cAAc,EACd,SAAS,EACT,YAAY,EACZ,OAAO,EACP,iBAAwB,EACxB,QAAQ,GACR,EAAE,kBAAkB,2CA0EpB"}

package/dist/context.d.ts

@@ -0,0 +1,51 @@
+import { type ConnectResult, type OneSatConfig, type OneSatProvider as OneSatProviderInterface } from '@1sat/connect';
+import { type ReactNode } from 'react';
+export interface OneSatContextValue {
+    /** The underlying provider instance */
+    provider: OneSatProviderInterface | null;
+    /** Whether the wallet is connected */
+    isConnected: boolean;
+    /** Whether a connection is in progress */
+    isConnecting: boolean;
+    /** The payment address (if connected) */
+    paymentAddress: string | null;
+    /** The ordinal address (if connected) */
+    ordinalAddress: string | null;
+    /** The identity public key (if connected) */
+    identityPubKey: string | null;
+    /** Connect to the wallet */
+    connect: () => Promise<ConnectResult>;
+    /** Disconnect from the wallet */
+    disconnect: () => Promise<void>;
+    /** Any connection error */
+    error: Error | null;
+}
+export interface OneSatProviderProps {
+    /** Configuration for the provider */
+    config?: OneSatConfig;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * React provider for 1Sat wallet functionality
+ *
+ * @example
+ * ```tsx
+ * import { OneSatProvider } from '@1sat/react'
+ *
+ * function App() {
+ *   return (
+ *     <OneSatProvider config={{ appName: 'My dApp' }}>
+ *       <MyApp />
+ *     </OneSatProvider>
+ *   )
+ * }
+ * ```
+ */
+export declare function OneSatProvider({ config, children }: OneSatProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the 1Sat context
+ * @throws Error if used outside of OneSatProvider
+ */
+export declare function useOneSatContext(): OneSatContextValue;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.tsx"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,IAAI,uBAAuB,EAE9C,MAAM,eAAe,CAAA;AACtB,OAAO,EACN,KAAK,SAAS,EAOd,MAAM,OAAO,CAAA;AAEd,MAAM,WAAW,kBAAkB;IAClC,uCAAuC;IACvC,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CAAA;IACxC,sCAAsC;IACtC,WAAW,EAAE,OAAO,CAAA;IACpB,0CAA0C;IAC1C,YAAY,EAAE,OAAO,CAAA;IACrB,yCAAyC;IACzC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,yCAAyC;IACzC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,6CAA6C;IAC7C,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,4BAA4B;IAC5B,OAAO,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAA;IACrC,iCAAiC;IACjC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/B,2BAA2B;IAC3B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACnB;AAID,MAAM,WAAW,mBAAmB;IACnC,qCAAqC;IACrC,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,yBAAyB;IACzB,QAAQ,EAAE,SAAS,CAAA;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,mBAAmB,2CAwGvE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAMrD"}

package/dist/hooks.d.ts

@@ -0,0 +1,155 @@
+import type { ListOptions, OrdinalOutput, TokenOutput } from '@1sat/connect';
+/**
+ * Main hook for 1Sat wallet interaction
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isConnected, connect, paymentAddress } = useOneSat()
+ *
+ *   if (!isConnected) {
+ *     return <button onClick={connect}>Connect Wallet</button>
+ *   }
+ *
+ *   return <p>Connected: {paymentAddress}</p>
+ * }
+ * ```
+ */
+export declare function useOneSat(): {
+    provider: import("@1sat/connect").OneSatProvider | null;
+    isConnected: boolean;
+    isConnecting: boolean;
+    paymentAddress: string | null;
+    ordinalAddress: string | null;
+    identityPubKey: string | null;
+    connect: () => Promise<import("@1sat/connect").ConnectResult>;
+    disconnect: () => Promise<void>;
+    error: Error | null;
+};
+/**
+ * Hook to get the wallet balance
+ *
+ * @example
+ * ```tsx
+ * function Balance() {
+ *   const { satoshis, isLoading } = useBalance()
+ *   if (isLoading) return <span>Loading...</span>
+ *   return <span>{satoshis} sats</span>
+ * }
+ * ```
+ */
+export declare function useBalance(): {
+    satoshis: number;
+    usd: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook to get ordinals from the wallet
+ *
+ * @example
+ * ```tsx
+ * function Gallery() {
+ *   const { ordinals, isLoading } = useOrdinals()
+ *   if (isLoading) return <span>Loading...</span>
+ *   return (
+ *     <div>
+ *       {ordinals.map(ord => (
+ *         <div key={ord.outpoint}>{ord.origin}</div>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export declare function useOrdinals(options?: ListOptions): {
+    ordinals: OrdinalOutput[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook to get tokens from the wallet
+ *
+ * @example
+ * ```tsx
+ * function Tokens() {
+ *   const { tokens, isLoading } = useTokens()
+ *   if (isLoading) return <span>Loading...</span>
+ *   return (
+ *     <div>
+ *       {tokens.map(token => (
+ *         <div key={token.outpoint}>
+ *           {token.symbol}: {token.amount}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTokens(options?: ListOptions): {
+    tokens: TokenOutput[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook for signing transactions
+ *
+ * @example
+ * ```tsx
+ * function SignTx() {
+ *   const { signTransaction, isLoading } = useSignTransaction()
+ *
+ *   const handleSign = async () => {
+ *     const result = await signTransaction(rawTx)
+ *     console.log('Signed:', result.txid)
+ *   }
+ *
+ *   return <button onClick={handleSign} disabled={isLoading}>Sign</button>
+ * }
+ * ```
+ */
+export declare function useSignTransaction(): {
+    signTransaction: (rawtx: string, description?: string) => Promise<import("@1sat/connect").SignTransactionResult>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook for signing messages (BSM)
+ *
+ * @example
+ * ```tsx
+ * function SignMessage() {
+ *   const { signMessage, isLoading } = useSignMessage()
+ *
+ *   const handleSign = async () => {
+ *     const result = await signMessage('Hello, World!')
+ *     console.log('Signature:', result.signature)
+ *   }
+ *
+ *   return <button onClick={handleSign} disabled={isLoading}>Sign Message</button>
+ * }
+ * ```
+ */
+export declare function useSignMessage(): {
+    signMessage: (message: string) => Promise<import("@1sat/connect").SignMessageResult>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook for inscribing ordinals
+ */
+export declare function useInscribe(): {
+    inscribe: (params: {
+        dataB64: string;
+        contentType: string;
+        destinationAddress?: string;
+        metaData?: Record<string, string>;
+    }) => Promise<import("@1sat/connect").InscribeResult>;
+    isLoading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEX,WAAW,EACX,aAAa,EACb,WAAW,EACX,MAAM,eAAe,CAAA;AAItB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS;;;;;;;;;;EAcxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU;;;;;;EAqCzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,WAAW;;;;;EAoChD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,WAAW;;;;;EAoC9C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB;6BAMlB,MAAM,gBAAgB,MAAM;;;EA2B3C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc;2BAMZ,MAAM;;;EA2BvB;AAED;;GAEG;AACH,wBAAgB,WAAW;uBAMV;QACd,OAAO,EAAE,MAAM,CAAA;QACf,WAAW,EAAE,MAAM,CAAA;QACnB,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACjC;;;EA2BF"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@1sat/connect';
+export { OneSatProvider, useOneSatContext, type OneSatContextValue, type OneSatProviderProps, } from './context';
+export { useOneSat, useBalance, useOrdinals, useTokens, useSignTransaction, useSignMessage, useInscribe, } from './hooks';
+export { ConnectButton, type ConnectButtonProps } from './ConnectButton';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA;AAG7B,OAAO,EACN,cAAc,EACd,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACxB,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,SAAS,EACT,UAAU,EACV,WAAW,EACX,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,WAAW,GACX,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,405 @@
+// src/index.ts
+export * from "@1sat/connect";
+
+// src/context.tsx
+import {
+  createOneSat
+} from "@1sat/connect";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var OneSatContext = createContext(null);
+function OneSatProvider({ config, children }) {
+  const [provider, setProvider] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [isConnecting, setIsConnecting] = useState(false);
+  const [paymentAddress, setPaymentAddress] = useState(null);
+  const [ordinalAddress, setOrdinalAddress] = useState(null);
+  const [identityPubKey, setIdentityPubKey] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (typeof window === "undefined")
+      return;
+    const p = createOneSat(config);
+    setProvider(p);
+    if (p.isConnected()) {
+      const addresses = p.getAddresses();
+      if (addresses) {
+        setIsConnected(true);
+        setPaymentAddress(addresses.paymentAddress);
+        setOrdinalAddress(addresses.ordinalAddress);
+        setIdentityPubKey(p.getIdentityPubKey());
+      }
+    }
+    const handleConnect = (result) => {
+      setIsConnected(true);
+      setPaymentAddress(result.paymentAddress);
+      setOrdinalAddress(result.ordinalAddress);
+      setIdentityPubKey(result.identityPubKey);
+    };
+    const handleDisconnect = () => {
+      setIsConnected(false);
+      setPaymentAddress(null);
+      setOrdinalAddress(null);
+      setIdentityPubKey(null);
+    };
+    p.on("connect", handleConnect);
+    p.on("disconnect", handleDisconnect);
+    return () => {
+      p.off("connect", handleConnect);
+      p.off("disconnect", handleDisconnect);
+    };
+  }, [config]);
+  const connect = useCallback(async () => {
+    if (!provider) {
+      throw new Error("Provider not initialized");
+    }
+    setIsConnecting(true);
+    setError(null);
+    try {
+      const result = await provider.connect();
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    } finally {
+      setIsConnecting(false);
+    }
+  }, [provider]);
+  const disconnect = useCallback(async () => {
+    if (!provider)
+      return;
+    await provider.disconnect();
+  }, [provider]);
+  const value = useMemo(() => ({
+    provider,
+    isConnected,
+    isConnecting,
+    paymentAddress,
+    ordinalAddress,
+    identityPubKey,
+    connect,
+    disconnect,
+    error
+  }), [
+    provider,
+    isConnected,
+    isConnecting,
+    paymentAddress,
+    ordinalAddress,
+    identityPubKey,
+    connect,
+    disconnect,
+    error
+  ]);
+  return /* @__PURE__ */ jsxDEV(OneSatContext.Provider, {
+    value,
+    children
+  }, undefined, false, undefined, this);
+}
+function useOneSatContext() {
+  const context = useContext(OneSatContext);
+  if (!context) {
+    throw new Error("useOneSatContext must be used within an OneSatProvider");
+  }
+  return context;
+}
+// src/hooks.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
+"use client";
+function useOneSat() {
+  const context = useOneSatContext();
+  return {
+    provider: context.provider,
+    isConnected: context.isConnected,
+    isConnecting: context.isConnecting,
+    paymentAddress: context.paymentAddress,
+    ordinalAddress: context.ordinalAddress,
+    identityPubKey: context.identityPubKey,
+    connect: context.connect,
+    disconnect: context.disconnect,
+    error: context.error
+  };
+}
+function useBalance() {
+  const { provider, isConnected } = useOneSatContext();
+  const [balance, setBalance] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const refetch = useCallback2(async () => {
+    if (!provider || !isConnected)
+      return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.getBalance();
+      setBalance(result);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected]);
+  useEffect2(() => {
+    if (isConnected) {
+      refetch();
+    } else {
+      setBalance(null);
+    }
+  }, [isConnected, refetch]);
+  return {
+    satoshis: balance?.satoshis ?? 0,
+    usd: balance?.usd ?? 0,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function useOrdinals(options) {
+  const { provider, isConnected } = useOneSatContext();
+  const [ordinals, setOrdinals] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const refetch = useCallback2(async () => {
+    if (!provider || !isConnected)
+      return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.getOrdinals(options);
+      setOrdinals(result);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected, options]);
+  useEffect2(() => {
+    if (isConnected) {
+      refetch();
+    } else {
+      setOrdinals([]);
+    }
+  }, [isConnected, refetch]);
+  return {
+    ordinals,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function useTokens(options) {
+  const { provider, isConnected } = useOneSatContext();
+  const [tokens, setTokens] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const refetch = useCallback2(async () => {
+    if (!provider || !isConnected)
+      return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.getTokens(options);
+      setTokens(result);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected, options]);
+  useEffect2(() => {
+    if (isConnected) {
+      refetch();
+    } else {
+      setTokens([]);
+    }
+  }, [isConnected, refetch]);
+  return {
+    tokens,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function useSignTransaction() {
+  const { provider, isConnected } = useOneSatContext();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const signTransaction = useCallback2(async (rawtx, description) => {
+    if (!provider || !isConnected) {
+      throw new Error("Wallet not connected");
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.signTransaction({ rawtx, description });
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected]);
+  return {
+    signTransaction,
+    isLoading,
+    error
+  };
+}
+function useSignMessage() {
+  const { provider, isConnected } = useOneSatContext();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const signMessage = useCallback2(async (message) => {
+    if (!provider || !isConnected) {
+      throw new Error("Wallet not connected");
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.signMessage(message);
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected]);
+  return {
+    signMessage,
+    isLoading,
+    error
+  };
+}
+function useInscribe() {
+  const { provider, isConnected } = useOneSatContext();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const inscribe = useCallback2(async (params) => {
+    if (!provider || !isConnected) {
+      throw new Error("Wallet not connected");
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await provider.inscribe(params);
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [provider, isConnected]);
+  return {
+    inscribe,
+    isLoading,
+    error
+  };
+}
+// src/ConnectButton.tsx
+import { jsxDEV as jsxDEV2, Fragment } from "react/jsx-dev-runtime";
+"use client";
+function truncateAddress(address) {
+  if (address.length <= 12)
+    return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function ConnectButton({
+  className,
+  style,
+  connectLabel = "Connect Wallet",
+  connectingLabel = "Connecting...",
+  connectedLabel,
+  onConnect,
+  onDisconnect,
+  onError,
+  disconnectOnClick = true,
+  children
+}) {
+  const {
+    isConnected,
+    isConnecting,
+    paymentAddress,
+    connect: providerConnect,
+    disconnect: providerDisconnect
+  } = useOneSat();
+  const connect = async () => {
+    try {
+      await providerConnect();
+      onConnect?.();
+    } catch (e) {
+      onError?.(e instanceof Error ? e : new Error(String(e)));
+    }
+  };
+  const disconnect = async () => {
+    try {
+      await providerDisconnect();
+      onDisconnect?.();
+    } catch (e) {
+      onError?.(e instanceof Error ? e : new Error(String(e)));
+    }
+  };
+  if (children) {
+    return /* @__PURE__ */ jsxDEV2(Fragment, {
+      children: children({
+        isConnected,
+        isConnecting,
+        address: paymentAddress,
+        connect,
+        disconnect
+      })
+    }, undefined, false, undefined, this);
+  }
+  if (isConnecting) {
+    return /* @__PURE__ */ jsxDEV2("button", {
+      className,
+      style,
+      disabled: true,
+      type: "button",
+      children: connectingLabel
+    }, undefined, false, undefined, this);
+  }
+  if (isConnected) {
+    const label = typeof connectedLabel === "function" ? connectedLabel(paymentAddress ?? "") : connectedLabel ?? truncateAddress(paymentAddress ?? "");
+    return /* @__PURE__ */ jsxDEV2("button", {
+      className,
+      style,
+      onClick: disconnectOnClick ? disconnect : undefined,
+      type: "button",
+      children: label
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV2("button", {
+    className,
+    style,
+    onClick: connect,
+    type: "button",
+    children: connectLabel
+  }, undefined, false, undefined, this);
+}
+export {
+  useTokens,
+  useSignTransaction,
+  useSignMessage,
+  useOrdinals,
+  useOneSatContext,
+  useOneSat,
+  useInscribe,
+  useBalance,
+  OneSatProvider,
+  ConnectButton
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@1sat/react",
+	"version": "0.0.1",
+	"description": "React hooks and components for 1Sat wallet integration",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": ["dist"],
+	"scripts": {
+		"build": "bun build ./src/index.ts --outdir ./dist --target browser --external react --external @1sat/connect && tsc --emitDeclarationOnly",
+		"dev": "tsc --watch"
+	},
+	"keywords": ["1sat", "bsv", "ordinals", "wallet", "sdk", "react", "hooks"],
+	"license": "MIT",
+	"dependencies": {
+		"@1sat/connect": "workspace:*"
+	},
+	"peerDependencies": {
+		"react": "^18.0.0 || ^19.0.0"
+	},
+	"devDependencies": {
+		"@types/react": "^19.0.0",
+		"react": "^19.0.0",
+		"typescript": "^5.9.3"
+	}
+}