@1sat/react 0.0.6 → 0.0.8

package/dist/ConnectButton.d.ts

@@ -1,56 +1,21 @@
 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 */
+    connectedLabel?: ReactNode | ((identityKey: string) => ReactNode);
     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;
+        identityKey: string | null;
         connect: () => Promise<void>;
-        disconnect: () => Promise<void>;
+        disconnect: () => 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

@@ -1 +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"}
+{"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,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IAC3B,YAAY,CAAC,EAAE,SAAS,CAAA;IACxB,eAAe,CAAC,EAAE,SAAS,CAAA;IAC3B,cAAc,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC,CAAA;IACjE,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAA;IACzB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAClB,WAAW,EAAE,OAAO,CAAA;QACpB,YAAY,EAAE,OAAO,CAAA;QACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;QAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;QAC5B,UAAU,EAAE,MAAM,IAAI,CAAA;KACtB,KAAK,SAAS,CAAA;CACf;AAOD,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/WalletSelector.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+export interface WalletSelectorProviderInfo {
+    type: string;
+    name: string;
+    icon?: string;
+    detected: boolean;
+    isConnecting: boolean;
+    connect: () => Promise<void>;
+}
+export interface WalletSelectorRenderProps {
+    providers: WalletSelectorProviderInfo[];
+    error: Error | null;
+}
+export interface WalletSelectorProps {
+    onClose?: () => void;
+    children: (props: WalletSelectorRenderProps) => ReactNode;
+}
+export declare function WalletSelector({ onClose, children }: WalletSelectorProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WalletSelector.d.ts.map

package/dist/WalletSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletSelector.d.ts","sourceRoot":"","sources":["../src/WalletSelector.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAyB,MAAM,OAAO,CAAA;AAG7D,MAAM,WAAW,0BAA0B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,OAAO,CAAA;IACrB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACzC,SAAS,EAAE,0BAA0B,EAAE,CAAA;IACvC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACnB;AAED,MAAM,WAAW,mBAAmB;IACnC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,yBAAyB,KAAK,SAAS,CAAA;CACzD;AAED,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,mBAAmB,2CA6BxE"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from '@1sat/connect';
-export { OneSatProvider, useOneSatContext, type OneSatContextValue, type OneSatProviderProps, } from './context';
-export { useBalance, useOrdinals, useTokens, useUtxos, useSignTransaction, useSignMessage, useInscribe, useSendOrdinals, useTransferToken, useCreateListing, usePurchaseListing, useCancelListing, } from './hooks';
+export { WalletProvider, useWallet, type WalletContextValue, type WalletProviderProps, type WalletStatus, } from './wallet-context';
 export { ConnectButton, type ConnectButtonProps } from './ConnectButton';
+export { WalletSelector, type WalletSelectorProps, type WalletSelectorProviderInfo, type WalletSelectorRenderProps, } from './WalletSelector';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,GAChB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA;AAG7B,OAAO,EACN,cAAc,EACd,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,YAAY,GACjB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EACN,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC9B,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -1,10 +1,12 @@
 "use client";
+
 // src/index.ts
 export * from "@1sat/connect";
 
-// src/context.tsx
+// src/wallet-context.tsx
 import {
-  createOneSat
+  connectWallet,
+  getAvailableProviders
 } from "@1sat/connect";
 import {
   createContext,
@@ -12,326 +14,167 @@ import {
   useContext,
   useEffect,
   useMemo,
+  useRef,
   useState
 } from "react";
 import { jsx } from "react/jsx-runtime";
-"use client";
-var OneSatContext = createContext(null);
-function OneSatProvider({
-  appName,
-  popupUrl,
-  timeout,
-  network,
+var STORAGE_KEY = "onesat_wallet_provider";
+function loadStored() {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw)
+      return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveStored(providerType, identityKey) {
+  if (typeof window === "undefined")
+    return;
+  localStorage.setItem(STORAGE_KEY, JSON.stringify({ providerType, identityKey }));
+}
+function clearStored() {
+  if (typeof window === "undefined")
+    return;
+  localStorage.removeItem(STORAGE_KEY);
+}
+var WalletContext = createContext(null);
+function WalletProvider({
+  autoDetect = true,
+  providers,
   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 [wallet, setWallet] = useState(null);
+  const [status, setStatus] = useState("disconnected");
+  const [identityKey, setIdentityKey] = useState(null);
+  const [providerType, setProviderType] = useState(null);
   const [error, setError] = useState(null);
-  useEffect(() => {
-    if (typeof window === "undefined")
-      return;
-    const p = createOneSat({ appName, popupUrl, timeout, network });
-    setProvider(p);
-    if (p.isConnected()) {
-      const addresses = p.getAddresses();
-      if (addresses) {
-        setIsConnected(true);
-        setPaymentAddress(addresses.paymentAddress);
-        setOrdinalAddress(addresses.ordinalAddress);
-        setIdentityPubKey(p.getIdentityPubKey());
+  const disconnectRef = useRef(null);
+  const availableProviders = useMemo(() => getAvailableProviders({ providers }), [providers]);
+  const applyResult = useCallback((result) => {
+    setWallet(result.wallet);
+    setIdentityKey(result.identityKey);
+    setProviderType(result.provider);
+    setStatus("connected");
+    setError(null);
+    disconnectRef.current = result.disconnect;
+    saveStored(result.provider, result.identityKey);
+  }, []);
+  const disconnect = useCallback(() => {
+    disconnectRef.current?.();
+    disconnectRef.current = null;
+    setWallet(null);
+    setIdentityKey(null);
+    setProviderType(null);
+    setStatus("disconnected");
+    setError(null);
+    clearStored();
+  }, []);
+  const connect = useCallback(async (selectedType) => {
+    setError(null);
+    if (selectedType) {
+      const provider = availableProviders.find((p) => p.type === selectedType);
+      if (!provider) {
+        setError(new Error(`Unknown provider: ${selectedType}`));
+        return;
+      }
+      setStatus("connecting");
+      try {
+        applyResult(await provider.connect());
+      } catch (e) {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setStatus("selecting");
       }
+      return;
     }
-    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);
-    };
-  }, [appName, popupUrl, timeout, network]);
-  const connect = useCallback(async () => {
-    if (!provider) {
-      throw new Error("Provider not initialized");
+    setStatus("detecting");
+    const result = await connectWallet({
+      autoDetect: true,
+      providers
+    });
+    if (result) {
+      applyResult(result);
+    } else {
+      setStatus("selecting");
     }
-    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);
+  }, [availableProviders, providers, applyResult]);
+  const mountRef = useRef({
+    autoDetect,
+    availableProviders,
+    connect,
+    applyResult
+  });
+  mountRef.current = { autoDetect, availableProviders, connect, applyResult };
+  useEffect(() => {
+    const {
+      autoDetect: auto,
+      availableProviders: providers2,
+      connect: doConnect,
+      applyResult: apply
+    } = mountRef.current;
+    const stored = loadStored();
+    if (stored) {
+      setStatus("connecting");
+      const provider = providers2.find((p) => p.type === stored.providerType);
+      if (provider) {
+        provider.connect().then(apply).catch(() => {
+          clearStored();
+          if (auto) {
+            doConnect();
+          } else {
+            setStatus("selecting");
+          }
+        });
+        return;
+      }
     }
-  }, [provider]);
-  const disconnect = useCallback(async () => {
-    if (!provider)
-      return;
-    await provider.disconnect();
-  }, [provider]);
+    if (auto) {
+      doConnect();
+    } else {
+      setStatus("selecting");
+    }
+  }, []);
   const value = useMemo(() => ({
-    provider,
-    isConnected,
-    isConnecting,
-    paymentAddress,
-    ordinalAddress,
-    identityPubKey,
+    wallet,
+    status,
+    identityKey,
+    providerType,
+    availableProviders,
     connect,
     disconnect,
     error
   }), [
-    provider,
-    isConnected,
-    isConnecting,
-    paymentAddress,
-    ordinalAddress,
-    identityPubKey,
+    wallet,
+    status,
+    identityKey,
+    providerType,
+    availableProviders,
     connect,
     disconnect,
     error
   ]);
-  return /* @__PURE__ */ jsx(OneSatContext.Provider, {
+  return /* @__PURE__ */ jsx(WalletContext.Provider, {
     value,
     children
   });
 }
-function useOneSatContext() {
-  const context = useContext(OneSatContext);
-  if (!context) {
-    throw new Error("useOneSatContext must be used within an OneSatProvider");
+function useWallet() {
+  const ctx = useContext(WalletContext);
+  if (!ctx) {
+    throw new Error("useWallet must be used within a WalletProvider");
   }
-  return context;
-}
-// src/hooks.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useRef, useState as useState2 } from "react";
-"use client";
-function useProviderAction(actionFn) {
-  const { provider, isConnected } = useOneSatContext();
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const actionRef = useRef(actionFn);
-  actionRef.current = actionFn;
-  const mutate = useCallback2(async (...args) => {
-    if (!provider || !isConnected)
-      throw new Error("Wallet not connected");
-    setIsLoading(true);
-    setError(null);
-    try {
-      return await actionRef.current(provider, ...args);
-    } catch (e) {
-      const err = e instanceof Error ? e : new Error(String(e));
-      setError(err);
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [provider, isConnected]);
-  return { mutate, isLoading, 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 {
-      setBalance(await provider.getBalance());
-    } 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(limit, offset) {
-  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 opts = limit !== undefined || offset !== undefined ? { limit, offset } : undefined;
-      setOrdinals(await provider.getOrdinals(opts));
-    } catch (e) {
-      setError(e instanceof Error ? e : new Error(String(e)));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [provider, isConnected, limit, offset]);
-  useEffect2(() => {
-    if (isConnected) {
-      refetch();
-    } else {
-      setOrdinals([]);
-    }
-  }, [isConnected, refetch]);
-  return { ordinals, isLoading, error, refetch };
-}
-function useTokens(limit, offset) {
-  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 opts = limit !== undefined || offset !== undefined ? { limit, offset } : undefined;
-      setTokens(await provider.getTokens(opts));
-    } catch (e) {
-      setError(e instanceof Error ? e : new Error(String(e)));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [provider, isConnected, limit, offset]);
-  useEffect2(() => {
-    if (isConnected) {
-      refetch();
-    } else {
-      setTokens([]);
-    }
-  }, [isConnected, refetch]);
-  return { tokens, isLoading, error, refetch };
-}
-function useUtxos() {
-  const { provider, isConnected } = useOneSatContext();
-  const [utxos, setUtxos] = useState2([]);
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const refetch = useCallback2(async () => {
-    if (!provider || !isConnected)
-      return;
-    setIsLoading(true);
-    setError(null);
-    try {
-      setUtxos(await provider.getUtxos());
-    } catch (e) {
-      setError(e instanceof Error ? e : new Error(String(e)));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [provider, isConnected]);
-  useEffect2(() => {
-    if (isConnected) {
-      refetch();
-    } else {
-      setUtxos([]);
-    }
-  }, [isConnected, refetch]);
-  return { utxos, isLoading, error, refetch };
-}
-function useSignTransaction() {
-  const {
-    mutate: signTransaction,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.signTransaction(request));
-  return { signTransaction, isLoading, error };
-}
-function useSignMessage() {
-  const {
-    mutate: signMessage,
-    isLoading,
-    error
-  } = useProviderAction((p, message) => p.signMessage(message));
-  return { signMessage, isLoading, error };
-}
-function useInscribe() {
-  const {
-    mutate: inscribe,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.inscribe(request));
-  return { inscribe, isLoading, error };
-}
-function useSendOrdinals() {
-  const {
-    mutate: sendOrdinals,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.sendOrdinals(request));
-  return { sendOrdinals, isLoading, error };
-}
-function useTransferToken() {
-  const {
-    mutate: transferToken,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.transferToken(request));
-  return { transferToken, isLoading, error };
-}
-function useCreateListing() {
-  const {
-    mutate: createListing,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.createListing(request));
-  return { createListing, isLoading, error };
-}
-function usePurchaseListing() {
-  const {
-    mutate: purchaseListing,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.purchaseListing(request));
-  return { purchaseListing, isLoading, error };
-}
-function useCancelListing() {
-  const {
-    mutate: cancelListing,
-    isLoading,
-    error
-  } = useProviderAction((p, request) => p.cancelListing(request));
-  return { cancelListing, isLoading, error };
+  return ctx;
 }
 // src/ConnectButton.tsx
 import { jsx as jsx2, Fragment } from "react/jsx-runtime";
 "use client";
-function truncateAddress(address) {
-  if (address.length <= 12)
-    return address;
-  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+function truncateIdentityKey(key) {
+  if (key.length <= 12)
+    return key;
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
 }
 function ConnectButton({
   className,
@@ -346,23 +189,24 @@ function ConnectButton({
   children
 }) {
   const {
-    isConnected,
-    isConnecting,
-    paymentAddress,
-    connect: providerConnect,
-    disconnect: providerDisconnect
-  } = useOneSatContext();
+    status,
+    identityKey,
+    connect: walletConnect,
+    disconnect: walletDisconnect
+  } = useWallet();
+  const isConnected = status === "connected";
+  const isConnecting = status === "detecting" || status === "connecting";
   const connect = async () => {
     try {
-      await providerConnect();
+      await walletConnect();
       onConnect?.();
     } catch (e) {
       onError?.(e instanceof Error ? e : new Error(String(e)));
     }
   };
-  const disconnect = async () => {
+  const disconnect = () => {
     try {
-      await providerDisconnect();
+      walletDisconnect();
       onDisconnect?.();
     } catch (e) {
       onError?.(e instanceof Error ? e : new Error(String(e)));
@@ -373,7 +217,7 @@ function ConnectButton({
       children: children({
         isConnected,
         isConnecting,
-        address: paymentAddress,
+        identityKey,
         connect,
         disconnect
       })
@@ -389,7 +233,7 @@ function ConnectButton({
     });
   }
   if (isConnected) {
-    const label = typeof connectedLabel === "function" ? connectedLabel(paymentAddress ?? "") : connectedLabel ?? truncateAddress(paymentAddress ?? "");
+    const label = typeof connectedLabel === "function" ? connectedLabel(identityKey ?? "") : connectedLabel ?? truncateIdentityKey(identityKey ?? "");
     return /* @__PURE__ */ jsx2("button", {
       className,
       style,
@@ -406,20 +250,37 @@ function ConnectButton({
     children: connectLabel
   });
 }
+// src/WalletSelector.tsx
+import { useCallback as useCallback2, useState as useState2 } from "react";
+import { jsx as jsx3, Fragment as Fragment2 } from "react/jsx-runtime";
+"use client";
+function WalletSelector({ onClose, children }) {
+  const { availableProviders, connect, error } = useWallet();
+  const [connectingType, setConnectingType] = useState2(null);
+  const handleConnect = useCallback2(async (providerType) => {
+    setConnectingType(providerType);
+    try {
+      await connect(providerType);
+      onClose?.();
+    } finally {
+      setConnectingType(null);
+    }
+  }, [connect, onClose]);
+  const providers = availableProviders.map((p) => ({
+    type: p.type,
+    name: p.name,
+    icon: p.icon,
+    detected: p.detected,
+    isConnecting: connectingType === p.type,
+    connect: () => handleConnect(p.type)
+  }));
+  return /* @__PURE__ */ jsx3(Fragment2, {
+    children: children({ providers, error })
+  });
+}
 export {
-  useUtxos,
-  useTransferToken,
-  useTokens,
-  useSignTransaction,
-  useSignMessage,
-  useSendOrdinals,
-  usePurchaseListing,
-  useOrdinals,
-  useOneSatContext,
-  useInscribe,
-  useCreateListing,
-  useCancelListing,
-  useBalance,
-  OneSatProvider,
+  useWallet,
+  WalletSelector,
+  WalletProvider,
   ConnectButton
 };

package/dist/wallet-context.d.ts

@@ -0,0 +1,22 @@
+import { type AvailableProvider, type WalletProviderConfig } from '@1sat/connect';
+import type { WalletInterface } from '@bsv/sdk';
+import { type ReactNode } from 'react';
+export type WalletStatus = 'disconnected' | 'detecting' | 'selecting' | 'connecting' | 'connected';
+export interface WalletContextValue {
+    wallet: WalletInterface | null;
+    status: WalletStatus;
+    identityKey: string | null;
+    providerType: string | null;
+    availableProviders: AvailableProvider[];
+    connect: (providerType?: string) => Promise<void>;
+    disconnect: () => void;
+    error: Error | null;
+}
+export interface WalletProviderProps {
+    autoDetect?: boolean;
+    providers?: WalletProviderConfig[];
+    children: ReactNode;
+}
+export declare function WalletProvider({ autoDetect, providers, children, }: WalletProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useWallet(): WalletContextValue;
+//# sourceMappingURL=wallet-context.d.ts.map

package/dist/wallet-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-context.d.ts","sourceRoot":"","sources":["../src/wallet-context.tsx"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,iBAAiB,EAEtB,KAAK,oBAAoB,EAGzB,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,EACN,KAAK,SAAS,EAQd,MAAM,OAAO,CAAA;AAEd,MAAM,MAAM,YAAY,GACrB,cAAc,GACd,WAAW,GACX,WAAW,GACX,YAAY,GACZ,WAAW,CAAA;AAEd,MAAM,WAAW,kBAAkB;IAClC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,MAAM,EAAE,YAAY,CAAA;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,kBAAkB,EAAE,iBAAiB,EAAE,CAAA;IACvC,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACjD,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACnB;AAED,MAAM,WAAW,mBAAmB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAA;IAClC,QAAQ,EAAE,SAAS,CAAA;CACnB;AAmCD,wBAAgB,cAAc,CAAC,EAC9B,UAAiB,EACjB,SAAS,EACT,QAAQ,GACR,EAAE,mBAAmB,2CA6IrB;AAED,wBAAgB,SAAS,IAAI,kBAAkB,CAM9C"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@1sat/react",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"description": "React hooks and components for 1Sat wallet integration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -19,12 +19,14 @@
 	"keywords": ["1sat", "bsv", "ordinals", "wallet", "sdk", "react", "hooks"],
 	"license": "MIT",
 	"dependencies": {
-		"@1sat/connect": "^0.0.9"
+		"@1sat/connect": "0.0.12"
 	},
 	"peerDependencies": {
+		"@bsv/sdk": "^2.0.0",
 		"react": "^18.0.0 || ^19.0.0"
 	},
 	"devDependencies": {
+		"@bsv/sdk": "^2.0.12",
 		"@types/react": "^19.0.0",
 		"react": "^19.0.0",
 		"typescript": "^5.9.3"

package/dist/context.d.ts

@@ -1,57 +0,0 @@
-import { type ConnectResult, 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 {
-    /** Name of the dApp (shown in approval popup) */
-    appName?: string;
-    /** Base URL for the wallet popup (default: https://1sat.market) */
-    popupUrl?: string;
-    /** Request timeout in milliseconds (default: 300000 = 5 minutes) */
-    timeout?: number;
-    /** Network to use (default: main) */
-    network?: 'main' | 'test';
-    /** Children to render */
-    children: ReactNode;
-}
-/**
- * React provider for 1Sat wallet functionality
- *
- * @example
- * ```tsx
- * import { OneSatProvider } from '@1sat/react'
- *
- * function App() {
- *   return (
- *     <OneSatProvider appName="My dApp">
- *       <MyApp />
- *     </OneSatProvider>
- *   )
- * }
- * ```
- */
-export declare function OneSatProvider({ appName, popupUrl, timeout, network, 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

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.tsx"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,aAAa,EAClB,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,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,yBAAyB;IACzB,QAAQ,EAAE,SAAS,CAAA;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,EAC9B,OAAO,EACP,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,GACR,EAAE,mBAAmB,2CAqGrB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAMrD"}

package/dist/hooks.d.ts

@@ -1,186 +0,0 @@
-import type { CancelListingRequest, CreateListingRequest, InscribeRequest, OrdinalOutput, PurchaseListingRequest, SendOrdinalsRequest, SignTransactionRequest, TokenOutput, TransferTokenRequest, Utxo } from '@1sat/connect';
-/**
- * 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 ordinals.map(ord => <div key={ord.outpoint}>{ord.origin}</div>)
- * }
- * ```
- */
-export declare function useOrdinals(limit?: number, offset?: number): {
-    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 tokens.map(t => <div key={t.outpoint}>{t.symbol}: {t.amount}</div>)
- * }
- * ```
- */
-export declare function useTokens(limit?: number, offset?: number): {
-    tokens: TokenOutput[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook to get payment UTXOs from the wallet
- *
- * @example
- * ```tsx
- * function Utxos() {
- *   const { utxos, refetch } = useUtxos()
- *   return <span>{utxos.length} UTXOs available</span>
- * }
- * ```
- */
-export declare function useUtxos(): {
-    utxos: Utxo[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-};
-/**
- * Hook for signing transactions
- *
- * @example
- * ```tsx
- * const { signTransaction, isLoading } = useSignTransaction()
- * const result = await signTransaction({ rawtx, description: 'Send payment' })
- * ```
- */
-export declare function useSignTransaction(): {
-    signTransaction: (request: SignTransactionRequest) => Promise<import("@1sat/connect").SignTransactionResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for signing messages (BSM)
- *
- * @example
- * ```tsx
- * const { signMessage, isLoading } = useSignMessage()
- * const result = await signMessage('Hello, World!')
- * ```
- */
-export declare function useSignMessage(): {
-    signMessage: (message: string) => Promise<import("@1sat/connect").SignMessageResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for inscribing ordinals
- *
- * @example
- * ```tsx
- * const { inscribe, isLoading } = useInscribe()
- * const result = await inscribe({ dataB64, contentType: 'text/plain' })
- * ```
- */
-export declare function useInscribe(): {
-    inscribe: (request: InscribeRequest) => Promise<import("@1sat/connect").InscribeResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for sending ordinals
- *
- * @example
- * ```tsx
- * const { sendOrdinals, isLoading } = useSendOrdinals()
- * await sendOrdinals({ outpoints: ['txid_0'], destinationAddress: 'addr' })
- * ```
- */
-export declare function useSendOrdinals(): {
-    sendOrdinals: (request: SendOrdinalsRequest) => Promise<import("@1sat/connect").SendResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for transferring tokens (BSV20/21)
- *
- * @example
- * ```tsx
- * const { transferToken, isLoading } = useTransferToken()
- * await transferToken({ tokenId: 'origin_0', amount: '100', destinationAddress: 'addr' })
- * ```
- */
-export declare function useTransferToken(): {
-    transferToken: (request: TransferTokenRequest) => Promise<import("@1sat/connect").SendResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for creating marketplace listings
- *
- * @example
- * ```tsx
- * const { createListing, isLoading } = useCreateListing()
- * await createListing({ outpoints: ['txid_0'], priceSatoshis: 100000 })
- * ```
- */
-export declare function useCreateListing(): {
-    createListing: (request: CreateListingRequest) => Promise<import("@1sat/connect").ListingResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for purchasing a listed ordinal
- *
- * @example
- * ```tsx
- * const { purchaseListing, isLoading } = usePurchaseListing()
- * await purchaseListing({ listingOutpoint: 'txid_0' })
- * ```
- */
-export declare function usePurchaseListing(): {
-    purchaseListing: (request: PurchaseListingRequest) => Promise<import("@1sat/connect").SendResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-/**
- * Hook for cancelling marketplace listings
- *
- * @example
- * ```tsx
- * const { cancelListing, isLoading } = useCancelListing()
- * await cancelListing({ listingOutpoints: ['txid_0'] })
- * ```
- */
-export declare function useCancelListing(): {
-    cancelListing: (request: CancelListingRequest) => Promise<import("@1sat/connect").SendResult>;
-    isLoading: boolean;
-    error: Error | null;
-};
-//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEX,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EAEf,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,oBAAoB,EACpB,IAAI,EACJ,MAAM,eAAe,CAAA;AA6CtB;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU;;;;;;EAkCzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAgC1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAgCxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ;;;;;EA4BvB;AAID;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB;;;;EASjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc;;;;EAO7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW;;;;EAO1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe;;;;EAS9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB;;;;EAS/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB;;;;EAS/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB;;;;EASjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB;;;;EAS/B"}