@solana/connector 0.0.0 → 0.1.0

package/dist/react.d.mts

@@ -0,0 +1,645 @@
+import { h as UnifiedConfig, d as ConnectorConfig, M as MobileWalletAdapterConfig, i as ClusterType, A as AccountInfo, N as ClipboardResult } from './wallet-standard-shim-Af7ejSld.mjs';
+export { b as ConnectorErrorBoundary, C as ConnectorProvider, c as ConnectorSnapshot, e as ConnectorState, D as DefaultConfigOptions, E as ExtendedConnectorConfig, U as UnifiedConfigOptions, W as WalletInfo, g as WalletStandardAccount, f as WalletStandardWallet, u as useConnector, a as useConnectorClient, w as withErrorBoundary } from './wallet-standard-shim-Af7ejSld.mjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, ComponentType, PropsWithChildren } from 'react';
+import { SolanaCluster, SolanaClusterId } from '@wallet-ui/core';
+export { SolanaCluster, SolanaClusterId } from '@wallet-ui/core';
+import { j as TransactionSigner, b as TransactionSignerCapabilities } from './transaction-signer-BtJPGXIg.mjs';
+import { TransactionModifyingSigner, SolanaClient, CompilableTransactionMessage, TransactionMessageWithBlockhashLifetime } from 'gill';
+export { Wallet, WalletAccount } from '@wallet-standard/base';
+import '@solana/web3.js';
+
+interface UnifiedProviderProps {
+    children: ReactNode;
+    config?: UnifiedConfig;
+    connectorConfig?: ConnectorConfig;
+    mobile?: MobileWalletAdapterConfig;
+    providers?: Array<{
+        component: ComponentType<PropsWithChildren>;
+        props?: Record<string, unknown>;
+    }>;
+}
+declare function UnifiedProvider({ children, config, connectorConfig, mobile, providers }: UnifiedProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @solana/connector - useCluster hook
+ *
+ * React hook for managing Solana cluster (network) state
+ */
+
+interface UseClusterReturn {
+    /** Currently active cluster */
+    cluster: SolanaCluster | null;
+    /** All available clusters */
+    clusters: SolanaCluster[];
+    /** Set the active cluster */
+    setCluster: (id: SolanaClusterId) => Promise<void>;
+    /** Whether the current cluster is mainnet */
+    isMainnet: boolean;
+    /** Whether the current cluster is devnet */
+    isDevnet: boolean;
+    /** Whether the current cluster is testnet */
+    isTestnet: boolean;
+    /** Whether the current cluster is running locally */
+    isLocal: boolean;
+    /** Solana Explorer base URL for the current cluster */
+    explorerUrl: string;
+    /** Cluster type (mainnet, devnet, testnet, localnet, custom) */
+    type: ClusterType | null;
+}
+/**
+ * Hook for managing Solana cluster (network) selection
+ *
+ * @example
+ * ```tsx
+ * function ClusterSwitcher() {
+ *   const { cluster, clusters, setCluster, isMainnet } = useCluster()
+ *
+ *   return (
+ *     <select
+ *       value={cluster?.id}
+ *       onChange={(e) => setCluster(e.target.value as SolanaClusterId)}
+ *     >
+ *       {clusters.map(c => (
+ *         <option key={c.id} value={c.id}>{c.label}</option>
+ *       ))}
+ *     </select>
+ *   )
+ * }
+ * ```
+ */
+declare function useCluster(): UseClusterReturn;
+
+/**
+ * @solana/connector - useAccount hook
+ *
+ * React hook for working with the connected wallet account
+ */
+
+interface UseAccountReturn {
+    /** The connected wallet address */
+    address: string | null;
+    /** Full account info object */
+    account: AccountInfo | null;
+    /** Whether a wallet is connected */
+    connected: boolean;
+    /** Shortened formatted address for display */
+    formatted: string;
+    /** Copy the address to clipboard with enhanced result */
+    copy: () => Promise<ClipboardResult>;
+    /** Whether the address was recently copied */
+    copied: boolean;
+    /** All available accounts from the connected wallet */
+    accounts: AccountInfo[];
+    /** Select a different account from the connected wallet */
+    selectAccount: (address: string) => Promise<void>;
+}
+/**
+ * Hook for working with the connected wallet account
+ * Provides formatted address, clipboard copying, and account selection
+ *
+ * @example
+ * ```tsx
+ * function AccountDisplay() {
+ *   const { address, formatted, copy, copied, connected } = useAccount()
+ *
+ *   if (!connected) return <p>Not connected</p>
+ *
+ *   return (
+ *     <button onClick={copy}>
+ *       {formatted} {copied && '✓'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useAccount(): UseAccountReturn;
+
+/**
+ * @solana/connector - useWalletInfo hook
+ *
+ * React hook for getting information about the connected wallet
+ */
+/**
+ * Simplified wallet information for display purposes
+ */
+interface WalletDisplayInfo {
+    /** Wallet name */
+    name: string;
+    /** Wallet icon/logo URL if available */
+    icon?: string;
+    /** Whether the wallet extension is installed */
+    installed: boolean;
+    /** Whether the wallet supports Solana connections */
+    connectable?: boolean;
+}
+/**
+ * Return value from useWalletInfo hook
+ */
+interface UseWalletInfoReturn {
+    /** Name of the connected wallet (e.g., 'Phantom', 'Solflare') */
+    name: string | null;
+    /** Wallet icon/logo URL if available */
+    icon: string | null;
+    /** Whether the wallet extension is installed */
+    installed: boolean;
+    /** Whether the wallet supports Solana connections */
+    connectable: boolean;
+    /** Whether currently connected to the wallet */
+    connected: boolean;
+    /** Whether a connection attempt is in progress */
+    connecting: boolean;
+    /** All available wallets */
+    wallets: WalletDisplayInfo[];
+}
+/**
+ * Hook for getting information about the connected wallet
+ * Provides wallet metadata, connection status, and capabilities
+ *
+ * @example
+ * ```tsx
+ * function WalletBadge() {
+ *   const { name, icon, connected, connecting } = useWalletInfo()
+ *
+ *   if (connecting) return <p>Connecting...</p>
+ *   if (!connected) return <p>No wallet connected</p>
+ *
+ *   return (
+ *     <div>
+ *       {icon && <img src={icon} alt={name} />}
+ *       <span>{name}</span>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useWalletInfo(): UseWalletInfoReturn;
+
+/**
+ * @solana/connector - useTransactionSigner hook
+ *
+ * React hook for transaction signing operations
+ * Provides a clean interface for signing and sending transactions
+ * with automatic signer creation and lifecycle management
+ */
+
+/**
+ * Return value from useTransactionSigner hook
+ */
+interface UseTransactionSignerReturn {
+    /**
+     * Transaction signer instance (null if not connected)
+     * Use this to sign and send transactions
+     */
+    signer: TransactionSigner | null;
+    /**
+     * Whether a signer is available and ready to use
+     * Useful for disabling transaction buttons
+     */
+    ready: boolean;
+    /**
+     * Current wallet address that will sign transactions
+     * Null if no wallet connected
+     */
+    address: string | null;
+    /**
+     * Signer capabilities (what operations are supported)
+     * Always available even if signer is null (shows all false)
+     */
+    capabilities: TransactionSignerCapabilities;
+}
+/**
+ * Hook for transaction signing operations
+ *
+ * Automatically creates a TransactionSigner when a wallet is connected,
+ * and provides convenient state for building transaction UIs.
+ *
+ * The signer is automatically recreated when:
+ * - Wallet connection state changes
+ * - Selected account changes
+ * - Active cluster/network changes
+ *
+ * @example
+ * ```tsx
+ * function SendTransaction() {
+ *   const { signer, ready, capabilities } = useTransactionSigner()
+ *   const [txSignature, setTxSignature] = useState<string | null>(null)
+ *   const [error, setError] = useState<string | null>(null)
+ *
+ *   const handleSend = async () => {
+ *     if (!signer) return
+ *
+ *     try {
+ *       const signature = await signer.signAndSendTransaction(transaction)
+ *       setTxSignature(signature)
+ *       setError(null)
+ *     } catch (err) {
+ *       setError(err instanceof Error ? err.message : 'Transaction failed')
+ *     }
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSend} disabled={!ready}>
+ *         {ready ? 'Send Transaction' : 'Connect Wallet'}
+ *       </button>
+ *
+ *       {!capabilities.canSend && ready && (
+ *         <p className="warning">
+ *           Your wallet doesn't support direct sending.
+ *           Transaction must be signed and broadcast separately.
+ *         </p>
+ *       )}
+ *
+ *       {txSignature && (
+ *         <p>Transaction sent: {txSignature}</p>
+ *       )}
+ *
+ *       {error && (
+ *         <p className="error">{error}</p>
+ *       )}
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using with multiple transactions
+ * function SendBatch() {
+ *   const { signer, ready, capabilities } = useTransactionSigner()
+ *
+ *   const handleSendBatch = async () => {
+ *     if (!signer) return
+ *
+ *     const transactions = [tx1, tx2, tx3]
+ *
+ *     // Check if batch signing is supported
+ *     if (capabilities.supportsBatchSigning) {
+ *       // More efficient: sign all at once
+ *       const signed = await signer.signAllTransactions(transactions)
+ *       // ... send signed transactions
+ *     } else {
+ *       // Fallback: sign and send one by one
+ *       const signatures = await signer.signAndSendTransactions(transactions)
+ *       console.log('All sent:', signatures)
+ *     }
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleSendBatch} disabled={!ready}>
+ *       Send {capabilities.supportsBatchSigning ? 'Batch' : 'Sequential'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using with message signing for authentication
+ * function SignInWithWallet() {
+ *   const { signer, ready, capabilities } = useTransactionSigner()
+ *
+ *   const handleSignIn = async () => {
+ *     if (!signer || !capabilities.canSignMessage) {
+ *       alert('Wallet does not support message signing')
+ *       return
+ *     }
+ *
+ *     const message = new TextEncoder().encode('Sign in to MyApp')
+ *     const signature = await signer.signMessage!(message)
+ *
+ *     // Send signature to backend for verification
+ *     await fetch('/api/auth/verify', {
+ *       method: 'POST',
+ *       body: JSON.stringify({
+ *         message: Array.from(message),
+ *         signature: Array.from(signature),
+ *         address: signer.address
+ *       })
+ *     })
+ *   }
+ *
+ *   if (!capabilities.canSignMessage) {
+ *     return <p>Message signing not supported</p>
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleSignIn} disabled={!ready}>
+ *       Sign In with Wallet
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useTransactionSigner(): UseTransactionSignerReturn;
+
+/**
+ * @solana/connector - useGillTransactionSigner hook
+ *
+ * React hook for gill-compatible transaction signing
+ * Use this when working with modern Solana libraries (@solana/kit, gill)
+ */
+
+/**
+ * Return value from useGillTransactionSigner hook
+ */
+interface UseGillTransactionSignerReturn {
+    /**
+     * Gill-compatible TransactionModifyingSigner instance (null if not connected)
+     * Use this with modern Solana libraries (@solana/kit, gill)
+     */
+    signer: TransactionModifyingSigner | null;
+    /**
+     * Whether a signer is available and ready to use
+     * Useful for disabling transaction buttons
+     */
+    ready: boolean;
+}
+/**
+ * Hook for gill-compatible transaction signing
+ *
+ * Creates a TransactionPartialSigner that's compatible with @solana/kit and gill,
+ * enabling seamless integration with modern Solana development patterns.
+ *
+ * This hook wraps the standard useTransactionSigner and adapts it to gill's
+ * interface, allowing you to use modern libraries without type incompatibilities.
+ *
+ * @example
+ * ```tsx
+ * import { useGillTransactionSigner } from '@solana/connector';
+ * import { getTransferSolInstruction } from 'gill/programs';
+ * import { address, pipe, createTransactionMessage } from 'gill';
+ *
+ * function ModernTransfer() {
+ *   const { signer, ready } = useGillTransactionSigner();
+ *
+ *   const handleTransfer = async (recipient: string, amount: number) => {
+ *     if (!signer) return;
+ *
+ *     // Fully type-safe with gill!
+ *     const instruction = getTransferSolInstruction({
+ *       source: signer, // No type errors
+ *       destination: address(recipient),
+ *       amount
+ *     });
+ *
+ *     const txMessage = pipe(
+ *       createTransactionMessage({ version: 0 }),
+ *       (tx) => setTransactionMessageFeePayerSigner(signer, tx), // Works!
+ *       // ...
+ *     );
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleTransfer} disabled={!ready}>
+ *       Send with Gill
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // For backward compatibility, continue using useTransactionSigner
+ * import { useTransactionSigner } from '@solana/connector';
+ *
+ * function LegacyTransfer() {
+ *   const { signer } = useTransactionSigner(); // Wallet adapter compatible
+ *   // Works with @solana/web3.js v1 and wallet-adapter
+ * }
+ * ```
+ */
+declare function useGillTransactionSigner(): UseGillTransactionSignerReturn;
+
+/**
+ * @solana/connector - useGillSolanaClient hook
+ *
+ * React hook for Gill's SolanaClient with built-in RPC and WebSocket subscriptions
+ * Provides rpc, rpcSubscriptions, sendAndConfirmTransaction, and simulateTransaction
+ */
+
+/**
+ * Return value from useGillSolanaClient hook
+ */
+interface UseGillSolanaClientReturn {
+    /**
+     * Gill SolanaClient instance with RPC and subscriptions (null if not available)
+     * Includes: rpc, rpcSubscriptions, sendAndConfirmTransaction, simulateTransaction
+     */
+    client: SolanaClient | null;
+    /**
+     * Whether a client is available and ready to use
+     */
+    ready: boolean;
+    /**
+     * Cluster type (mainnet, devnet, testnet, localnet, custom)
+     */
+    clusterType: ClusterType | null;
+}
+/**
+ * Hook for Gill's SolanaClient with automatic RPC and WebSocket subscription management
+ *
+ * Creates a fully configured SolanaClient based on the current cluster, providing:
+ * - Type-safe RPC client
+ * - WebSocket subscription client
+ * - Built-in sendAndConfirmTransaction helper
+ * - Built-in simulateTransaction helper
+ *
+ * The client is automatically recreated when the cluster changes.
+ *
+ * @example
+ * ```tsx
+ * import { useGillSolanaClient, useGillTransactionSigner } from '@solana/connector';
+ * import { signTransactionMessageWithSigners } from 'gill';
+ *
+ * function SendTransaction() {
+ *   const { client, ready } = useGillSolanaClient();
+ *   const { signer } = useGillTransactionSigner();
+ *
+ *   const handleSend = async (transaction) => {
+ *     if (!client || !signer) return;
+ *
+ *     // Sign the transaction
+ *     const signed = await signTransactionMessageWithSigners(transaction);
+ *
+ *     // Send and confirm using Gill's built-in helper
+ *     await client.sendAndConfirmTransaction(signed, {
+ *       commitment: 'confirmed'
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSend} disabled={!ready}>
+ *       Send Transaction
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Simulating a transaction
+ * function SimulateTransaction() {
+ *   const { client } = useGillSolanaClient();
+ *
+ *   const handleSimulate = async (transaction) => {
+ *     if (!client) return;
+ *
+ *     const simulation = await client.simulateTransaction(transaction, {
+ *       sigVerify: false,
+ *       commitment: 'processed'
+ *     });
+ *
+ *     console.log('Simulation result:', simulation);
+ *   };
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Direct RPC access
+ * function GetBalance() {
+ *   const { client } = useGillSolanaClient();
+ *
+ *   const fetchBalance = async (address: Address) => {
+ *     if (!client) return;
+ *
+ *     const balance = await client.rpc.getBalance(address).send();
+ *     console.log('Balance:', balance);
+ *   };
+ * }
+ * ```
+ */
+declare function useGillSolanaClient(): UseGillSolanaClientReturn;
+
+/**
+ * @solana/connector - useTransactionPreparer hook
+ *
+ * React hook for preparing transactions with automatic optimization
+ * Handles blockhash fetching, compute unit limits, and transaction simulation
+ */
+
+/**
+ * Options for transaction preparation
+ */
+interface TransactionPrepareOptions {
+    /**
+     * Multiplier applied to the simulated compute unit value
+     * @default 1.1 (10% buffer)
+     */
+    computeUnitLimitMultiplier?: number;
+    /**
+     * Whether to force reset the compute unit limit value (if one is already set)
+     * using the simulation response and computeUnitLimitMultiplier
+     * @default false
+     */
+    computeUnitLimitReset?: boolean;
+    /**
+     * Whether to force reset the latest blockhash (if one is already set)
+     * @default true
+     */
+    blockhashReset?: boolean;
+}
+/**
+ * Return value from useTransactionPreparer hook
+ */
+interface UseTransactionPreparerReturn {
+    /**
+     * Prepare a transaction for sending
+     * Automatically adds:
+     * - Compute unit limit (via simulation with optional multiplier)
+     * - Latest blockhash (if not already set)
+     *
+     * @param transaction - The transaction to prepare
+     * @param options - Optional preparation settings
+     * @returns Prepared transaction with blockhash lifetime set
+     */
+    prepare: <TMessage extends CompilableTransactionMessage>(transaction: TMessage, options?: TransactionPrepareOptions) => Promise<TMessage & TransactionMessageWithBlockhashLifetime>;
+    /**
+     * Whether the preparer is ready to use
+     * False if Solana client is not available
+     */
+    ready: boolean;
+}
+/**
+ * Hook for preparing transactions with automatic optimization
+ *
+ * Uses Gill's prepareTransaction utility to:
+ * 1. Simulate the transaction to determine optimal compute units
+ * 2. Set compute unit limit (with configurable multiplier for safety margin)
+ * 3. Fetch and set the latest blockhash (if not already present)
+ *
+ * This significantly improves transaction landing rates by ensuring proper
+ * compute budget allocation and fresh blockhashes.
+ *
+ * @example
+ * ```tsx
+ * import { useTransactionPreparer, useGillTransactionSigner } from '@solana/connector';
+ * import { pipe, createTransactionMessage, appendTransactionMessageInstructions } from 'gill';
+ * import { getTransferSolInstruction } from 'gill/programs';
+ *
+ * function SendOptimizedTransaction() {
+ *   const { prepare, ready } = useTransactionPreparer();
+ *   const { signer } = useGillTransactionSigner();
+ *   const { client } = useGillSolanaClient();
+ *
+ *   const handleSend = async (recipient: string, amount: bigint) => {
+ *     if (!ready || !signer || !client) return;
+ *
+ *     // Build transaction message
+ *     const tx = pipe(
+ *       createTransactionMessage({ version: 0 }),
+ *       tx => setTransactionMessageFeePayerSigner(signer, tx),
+ *       tx => appendTransactionMessageInstructions([
+ *         getTransferSolInstruction({
+ *           source: signer,
+ *           destination: address(recipient),
+ *           amount: lamports(amount),
+ *         })
+ *       ], tx)
+ *     );
+ *
+ *     // Prepare: auto-adds compute units + blockhash
+ *     const prepared = await prepare(tx);
+ *
+ *     // Sign
+ *     const signed = await signTransactionMessageWithSigners(prepared);
+ *
+ *     // Send and confirm
+ *     await client.sendAndConfirmTransaction(signed);
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSend} disabled={!ready}>
+ *       Send Optimized Transaction
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom compute unit multiplier for high-priority transactions
+ * const { prepare } = useTransactionPreparer();
+ *
+ * const prepared = await prepare(transaction, {
+ *   computeUnitLimitMultiplier: 1.3, // 30% buffer instead of default 10%
+ *   blockhashReset: true // Always fetch fresh blockhash
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Force reset compute units even if already set
+ * const { prepare } = useTransactionPreparer();
+ *
+ * const prepared = await prepare(transaction, {
+ *   computeUnitLimitReset: true, // Re-simulate and reset compute units
+ *   computeUnitLimitMultiplier: 1.2
+ * });
+ * ```
+ */
+declare function useTransactionPreparer(): UseTransactionPreparerReturn;
+
+export { AccountInfo, UnifiedProvider as AppProvider, ClusterType, ConnectorConfig, MobileWalletAdapterConfig, type TransactionPrepareOptions, UnifiedConfig, UnifiedProvider, type UnifiedProviderProps, type UseAccountReturn, type UseClusterReturn, type UseGillSolanaClientReturn, type UseGillTransactionSignerReturn, type UseTransactionPreparerReturn, type UseTransactionSignerReturn, type UseWalletInfoReturn, useAccount, useCluster, useGillSolanaClient, useGillTransactionSigner, useTransactionPreparer, useTransactionSigner, useWalletInfo };