otx-btc-wallet-react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,436 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { ResolvedConfig, AddressType, WalletAccount, BitcoinConnector, ConnectionStatus, BitcoinNetwork, SignPsbtOptions } from 'otx-btc-wallet-core';
+
+interface BtcWalletProviderProps {
+    /** Configuration created with createConfig() */
+    config: ResolvedConfig;
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * Provider component for otx-btc-wallet
+ *
+ * @example
+ * ```tsx
+ * import { BtcWalletProvider } from 'otx-btc-wallet-react';
+ * import { config } from './config';
+ *
+ * function App() {
+ *   return (
+ *     <BtcWalletProvider config={config}>
+ *       <YourApp />
+ *     </BtcWalletProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function BtcWalletProvider({ config, children, }: BtcWalletProviderProps): ReactNode;
+
+/**
+ * Context for otx-btc-wallet configuration
+ */
+declare const BtcWalletContext: react.Context<ResolvedConfig | null>;
+/**
+ * Hook to access the otx-btc-wallet config
+ * @throws Error if used outside of BtcWalletProvider
+ */
+declare function useConfig(): ResolvedConfig;
+
+interface UseAccountReturn {
+    /** Connected address */
+    address: string | undefined;
+    /** Connected public key */
+    publicKey: string | undefined;
+    /** Address type */
+    addressType: AddressType | undefined;
+    /** Full account object */
+    account: WalletAccount | undefined;
+    /** Active connector */
+    connector: BitcoinConnector | undefined;
+    /** Connection status */
+    status: ConnectionStatus;
+    /** Is connected */
+    isConnected: boolean;
+    /** Is connecting */
+    isConnecting: boolean;
+    /** Is disconnected */
+    isDisconnected: boolean;
+    /** Is reconnecting */
+    isReconnecting: boolean;
+}
+/**
+ * Hook to get current account state
+ *
+ * @example
+ * ```tsx
+ * function Profile() {
+ *   const { address, isConnected, connector } = useAccount();
+ *
+ *   if (!isConnected) return <div>Not connected</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Address: {address}</p>
+ *       <p>Connected via {connector?.name}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAccount(): UseAccountReturn;
+
+type ConnectArgs = {
+    connector: BitcoinConnector;
+    network?: BitcoinNetwork;
+};
+interface UseConnectReturn {
+    /** Connect to a wallet (fire-and-forget) */
+    connect: (args: ConnectArgs) => void;
+    /** Connect to a wallet (returns promise) */
+    connectAsync: (args: ConnectArgs) => Promise<WalletAccount>;
+    /** Available connectors */
+    connectors: BitcoinConnector[];
+    /** Last error */
+    error: Error | null;
+    /** Is currently connecting */
+    isLoading: boolean;
+    /** Did connection fail */
+    isError: boolean;
+    /** Did connection succeed */
+    isSuccess: boolean;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to connect to a wallet
+ *
+ * @example
+ * ```tsx
+ * function ConnectButtons() {
+ *   const { connect, connectors, isLoading, error } = useConnect();
+ *
+ *   return (
+ *     <div>
+ *       {connectors.map((connector) => (
+ *         <button
+ *           key={connector.id}
+ *           onClick={() => connect({ connector })}
+ *           disabled={isLoading}
+ *         >
+ *           Connect {connector.name}
+ *         </button>
+ *       ))}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useConnect(): UseConnectReturn;
+
+interface UseDisconnectReturn {
+    /** Disconnect from wallet (fire-and-forget) */
+    disconnect: () => void;
+    /** Disconnect from wallet (returns promise) */
+    disconnectAsync: () => Promise<void>;
+    /** Is currently disconnecting */
+    isLoading: boolean;
+    /** Did disconnect fail */
+    isError: boolean;
+    /** Did disconnect succeed */
+    isSuccess: boolean;
+    /** Last error */
+    error: Error | null;
+}
+/**
+ * Hook to disconnect from wallet
+ *
+ * @example
+ * ```tsx
+ * function DisconnectButton() {
+ *   const { disconnect, isLoading } = useDisconnect();
+ *
+ *   return (
+ *     <button onClick={disconnect} disabled={isLoading}>
+ *       Disconnect
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDisconnect(): UseDisconnectReturn;
+
+interface UseNetworkReturn {
+    /** Current network */
+    network: BitcoinNetwork;
+}
+/**
+ * Hook to get current network
+ *
+ * @example
+ * ```tsx
+ * function NetworkInfo() {
+ *   const { network } = useNetwork();
+ *
+ *   return <p>Network: {network}</p>;
+ * }
+ * ```
+ */
+declare function useNetwork(): UseNetworkReturn;
+
+interface UseSendTransactionReturn {
+    /** Send transaction (fire-and-forget) */
+    sendTransaction: (args: {
+        to: string;
+        amount: number;
+    }) => void;
+    /** Send transaction (returns promise with txid) */
+    sendTransactionAsync: (args: {
+        to: string;
+        amount: number;
+    }) => Promise<string>;
+    /** Transaction ID */
+    data: string | undefined;
+    /** Last error */
+    error: Error | null;
+    /** Is sending */
+    isLoading: boolean;
+    /** Did send fail */
+    isError: boolean;
+    /** Did send succeed */
+    isSuccess: boolean;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to send a Bitcoin transaction
+ *
+ * @example
+ * ```tsx
+ * function SendForm() {
+ *   const { sendTransaction, isLoading, data, error } = useSendTransaction();
+ *
+ *   const handleSend = () => {
+ *     sendTransaction({ to: 'bc1q...', amount: 10000 }); // 10000 sats
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSend} disabled={isLoading}>
+ *         Send 10,000 sats
+ *       </button>
+ *       {data && <p>TX: {data}</p>}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSendTransaction(): UseSendTransactionReturn;
+
+interface UseSignMessageReturn {
+    /** Sign message (fire-and-forget) */
+    signMessage: (args: {
+        message: string;
+    }) => void;
+    /** Sign message (returns promise with signature) */
+    signMessageAsync: (args: {
+        message: string;
+    }) => Promise<string>;
+    /** Signature */
+    data: string | undefined;
+    /** Last error */
+    error: Error | null;
+    /** Is signing */
+    isLoading: boolean;
+    /** Did signing fail */
+    isError: boolean;
+    /** Did signing succeed */
+    isSuccess: boolean;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to sign a message
+ *
+ * @example
+ * ```tsx
+ * function SignMessage() {
+ *   const { signMessage, isLoading, data } = useSignMessage();
+ *
+ *   const handleSign = () => {
+ *     signMessage({ message: 'Hello, Bitcoin!' });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSign} disabled={isLoading}>
+ *         Sign Message
+ *       </button>
+ *       {data && <p>Signature: {data}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSignMessage(): UseSignMessageReturn;
+
+interface UseSignPsbtReturn {
+    /** Sign PSBT (fire-and-forget) */
+    signPsbt: (args: {
+        psbt: string;
+        options?: SignPsbtOptions;
+    }) => void;
+    /** Sign PSBT (returns promise with signed PSBT hex) */
+    signPsbtAsync: (args: {
+        psbt: string;
+        options?: SignPsbtOptions;
+    }) => Promise<string>;
+    /** Signed PSBT hex */
+    data: string | undefined;
+    /** Last error */
+    error: Error | null;
+    /** Is signing */
+    isLoading: boolean;
+    /** Did signing fail */
+    isError: boolean;
+    /** Did signing succeed */
+    isSuccess: boolean;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to sign a PSBT
+ *
+ * @example
+ * ```tsx
+ * function SignPsbt() {
+ *   const { signPsbt, isLoading, data } = useSignPsbt();
+ *
+ *   const handleSign = () => {
+ *     signPsbt({
+ *       psbt: '70736274ff01...',
+ *       options: { autoFinalize: true }
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSign} disabled={isLoading}>
+ *         Sign PSBT
+ *       </button>
+ *       {data && <p>Signed: {data.slice(0, 20)}...</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSignPsbt(): UseSignPsbtReturn;
+
+interface UseSignPsbtsReturn {
+    /** Sign multiple PSBTs (fire-and-forget) */
+    signPsbts: (args: {
+        psbts: string[];
+        options?: SignPsbtOptions;
+    }) => void;
+    /** Sign multiple PSBTs (returns promise with signed PSBT hexes) */
+    signPsbtsAsync: (args: {
+        psbts: string[];
+        options?: SignPsbtOptions;
+    }) => Promise<string[]>;
+    /** Signed PSBT hexes */
+    data: string[] | undefined;
+    /** Last error */
+    error: Error | null;
+    /** Is signing */
+    isLoading: boolean;
+    /** Did signing fail */
+    isError: boolean;
+    /** Did signing succeed */
+    isSuccess: boolean;
+    /** Is batch signing supported by current connector */
+    isSupported: boolean;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to sign multiple PSBTs (batch signing)
+ *
+ * @example
+ * ```tsx
+ * function BatchSign() {
+ *   const { signPsbts, isLoading, isSupported, data } = useSignPsbts();
+ *
+ *   if (!isSupported) {
+ *     return <p>Batch signing not supported by this wallet</p>;
+ *   }
+ *
+ *   const handleSign = () => {
+ *     signPsbts({
+ *       psbts: ['70736274ff01...', '70736274ff02...'],
+ *       options: { autoFinalize: true }
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSign} disabled={isLoading}>
+ *       Sign {2} PSBTs
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSignPsbts(): UseSignPsbtsReturn;
+
+interface UseMultiAddressReturn {
+    /** All available addresses from the wallet */
+    addresses: WalletAccount[];
+    /** Payment address (for sending/receiving BTC) */
+    paymentAddress: WalletAccount | null;
+    /** Ordinals address (for NFTs/inscriptions) */
+    ordinalsAddress: WalletAccount | null;
+    /** Currently selected primary address */
+    primaryAddress: WalletAccount | null;
+    /** Set the primary address */
+    setPrimaryAddress: (address: WalletAccount) => void;
+    /** Is loading addresses */
+    isLoading: boolean;
+    /** Refresh addresses from wallet */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to manage multiple addresses from a connected wallet
+ *
+ * Xverse and Leather wallets provide both payment and ordinals addresses.
+ * This hook helps manage and switch between them.
+ *
+ * @example
+ * ```tsx
+ * function MultiAddressDisplay() {
+ *   const {
+ *     paymentAddress,
+ *     ordinalsAddress,
+ *     primaryAddress,
+ *     setPrimaryAddress
+ *   } = useMultiAddress();
+ *
+ *   return (
+ *     <div>
+ *       <h3>Payment: {paymentAddress?.address}</h3>
+ *       <h3>Ordinals: {ordinalsAddress?.address}</h3>
+ *       <select onChange={(e) => {
+ *         const addr = e.target.value === 'payment' ? paymentAddress : ordinalsAddress;
+ *         if (addr) setPrimaryAddress(addr);
+ *       }}>
+ *         <option value="payment">Payment</option>
+ *         <option value="ordinals">Ordinals</option>
+ *       </select>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMultiAddress(): UseMultiAddressReturn;
+
+export { BtcWalletContext, BtcWalletProvider, type BtcWalletProviderProps, type ConnectArgs, type UseAccountReturn, type UseConnectReturn, type UseDisconnectReturn, type UseMultiAddressReturn, type UseNetworkReturn, type UseSendTransactionReturn, type UseSignMessageReturn, type UseSignPsbtReturn, type UseSignPsbtsReturn, useAccount, useConfig, useConnect, useDisconnect, useMultiAddress, useNetwork, useSendTransaction, useSignMessage, useSignPsbt, useSignPsbts };