JSPM

import {
  ConnectorProvider,
  getDefaultConfig,
  useConnector,
  useAccount,
  useTransactionSigner
} from '@solana/connector';

// 1. Wrap your app
function App() {
  return (
    <ConnectorProvider config={getDefaultConfig({ appName: "My App" })}>
      <WalletButton />
    </ConnectorProvider>
  );
}

// 2. Connect wallet
function WalletButton() {
  const { wallets, select, connected, disconnect } = useConnector();
  const { address, formatted } = useAccount();

  if (!connected) {
    return wallets.map(w => (
      <button key={w.name} onClick={() => select(w.name)}>
        Connect {w.name}
      </button>
    ));
  }

  return (
    <>
      <span>{formatted}</span>
      <button onClick={disconnect}>Disconnect</button>
    </>
  );
}

// 3. Sign transactions
function SendTransaction() {
  const { signer, ready } = useTransactionSigner();

  const handleSend = async () => {
    const signature = await signer.signAndSendTransaction(transaction);
  };

  return <button onClick={handleSend} disabled={!ready}>Send</button>;
}

// React
import { useConnector, useTransactionSigner, useAccount } from '@solana/connector';

// Headless (Vue, Svelte, vanilla JS)
import { ConnectorClient, getDefaultConfig } from '@solana/connector/headless';

const client = new ConnectorClient(getDefaultConfig({ appName: 'My App' }));
await client.select('Phantom');

import { useConnector } from '@solana/connector';

function Component() {
    const {
        // State
        wallets, // WalletInfo[] - All available wallets
        selectedWallet, // Wallet | null - Currently connected wallet
        accounts, // AccountInfo[] - Connected accounts
        connected, // boolean - Connection status
        connecting, // boolean - Connecting in progress

        // Actions
        select, // (walletName: string) => Promise<void>
        disconnect, // () => Promise<void>
    } = useConnector();
}

import { useAccount } from '@solana/connector';

function Component() {
    const {
        address, // string | null - Full wallet address
        formatted, // string - Shortened address (e.g., "5Gv8...x3kF")
        copy, // () => Promise<boolean> - Copy address to clipboard
        copied, // boolean - True for 2s after copying
        connected, // boolean - Connection status
        accounts, // AccountInfo[] - All accounts
        selectAccount, // (address: string) => Promise<void>
    } = useAccount();
}

import { useCluster } from '@solana/connector';

function Component() {
    const {
        cluster, // SolanaCluster | null - Active cluster
        clusters, // SolanaCluster[] - Available clusters
        setCluster, // (id: SolanaClusterId) => Promise<void>
        isMainnet, // boolean - Convenience flags
        isDevnet, // boolean
        rpcUrl, // string - RPC endpoint URL
        explorerUrl, // string - Solana Explorer base URL
    } = useCluster();
}

import { useTransactionSigner } from '@solana/connector';

function SendTx() {
  const { signer, ready, capabilities } = useTransactionSigner();

  // Check capabilities
  console.log('Can sign:', capabilities.canSign);
  console.log('Can send:', capabilities.canSend);
  console.log('Can sign messages:', capabilities.canSignMessage);
  console.log('Batch support:', capabilities.supportsBatchSigning);

  const handleSend = async () => {
    if (!signer) return;

    try {
      // Sign and send a transaction
      const signature = await signer.signAndSendTransaction(transaction);
      console.log('Success:', signature);

      // Or just sign without sending
      const signed = await signer.signTransaction(transaction);

      // Or sign multiple transactions
      const signedBatch = await signer.signAllTransactions([tx1, tx2, tx3]);

      // Or sign and send multiple
      const signatures = await signer.signAndSendTransactions([tx1, tx2]);

    } catch (error) {
      if (error instanceof TransactionSignerError) {
        console.error('Signing error:', error.code, error.message);
      }
    }
  };

  return (
    <button onClick={handleSend} disabled={!ready}>
      Send Transaction
    </button>
  );
}

import { isTransactionSignerError, TransactionSignerError } from '@solana/connector';

try {
    await signer.signAndSendTransaction(tx);
} catch (error) {
    if (isTransactionSignerError(error)) {
        switch (error.code) {
            case 'WALLET_NOT_CONNECTED':
                // Show connect prompt
                break;
            case 'FEATURE_NOT_SUPPORTED':
                // Show unsupported feature message
                break;
            case 'SIGNING_FAILED':
                // User rejected or signing failed
                break;
            case 'SEND_FAILED':
                // Transaction broadcast failed
                break;
        }
    }
}

import { useConnectorClient } from '@solana/connector';

function AnalyticsTracker() {
    const client = useConnectorClient();

    useEffect(() => {
        if (!client) return;

        // Subscribe to events
        const unsubscribe = client.on(event => {
            switch (event.type) {
                case 'wallet:connected':
                    analytics.track('Wallet Connected', {
                        wallet: event.wallet,
                        account: event.account,
                        timestamp: event.timestamp,
                    });
                    break;

                case 'wallet:disconnected':
                    analytics.track('Wallet Disconnected');
                    break;

                case 'cluster:changed':
                    analytics.track('Network Changed', {
                        from: event.previousCluster,
                        to: event.cluster,
                    });
                    break;

                case 'error':
                    errorTracker.captureException(event.error, {
                        context: event.context,
                    });
                    break;
            }
        });

        return unsubscribe;
    }, [client]);

    return null;
}

import { ConnectorDebugPanel } from '@solana/connector';

function App() {
  return (
    <ConnectorProvider config={config}>
      {/* Only visible in development mode */}
      {process.env.NODE_ENV === 'development' && <ConnectorDebugPanel />}
      <YourApp />
    </ConnectorProvider>
  );
}

<ConnectorDebugPanel
  position="top-left"    // 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
  defaultOpen={true}
  zIndex={10000}
/>

import { ConnectionPool, createConnectionPool } from '@solana/connector/headless';
import { Connection } from '@solana/web3.js';

// Create custom pool
const pool = createConnectionPool({
    maxSize: 10,
    createConnection: cluster => {
        return new Connection(cluster.endpoint, {
            commitment: 'confirmed',
        });
    },
});

// Get or create connection for a cluster
const connection = pool.get(currentCluster);
const balance = await connection.getBalance(publicKey);

// Clear specific connection when settings change
pool.clear('solana:mainnet');

// Get pool statistics
const stats = pool.getStats();
console.log(`Pool: ${stats.size}/${stats.maxSize}`);
console.log(`Hit rate: ${(stats.hits / (stats.hits + stats.misses)) * 100}%`);

import { getConnectionPool } from '@solana/connector/headless';

const pool = getConnectionPool();
const connection = pool.get(cluster);

import { useConnectorClient } from '@solana/connector';

function HealthMonitor() {
  const client = useConnectorClient();

  if (!client) return null;

  const health = client.getHealth();

  return (
    <div>
      <h3>Connector Health</h3>
      <div>Initialized: {health.initialized ? '✓' : '✗'}</div>
      <div>Wallet Standard: {health.walletStandardAvailable ? '✓' : '✗'}</div>
      <div>Storage: {health.storageAvailable ? '✓' : '✗'}</div>
      <div>Wallets Detected: {health.walletsDetected}</div>

      {health.errors.length > 0 && (
        <div className="errors">
          {health.errors.map(err => <div key={err}>{err}</div>)}
        </div>
      )}
    </div>
  );
}

import { useTransactionSigner, useConnector } from '@solana/connector';
import { createWalletAdapterCompat } from '@solana/connector/compat';

function JupiterIntegration() {
  const { signer } = useTransactionSigner();
  const { disconnect } = useConnector();

  // Create wallet-adapter compatible interface
  const walletAdapter = createWalletAdapterCompat(signer, {
    disconnect: async () => {
      await disconnect();
    },
    onError: (error, operation) => {
      console.error(`Wallet adapter error in ${operation}:`, error);
    }
  });

  // Use with Jupiter, Serum, or any wallet-adapter library
  return <JupiterTerminal wallet={walletAdapter} />;
}

import { getDefaultConfig } from '@solana/connector';

const config = getDefaultConfig({
    appName: 'My App', // Required
    autoConnect: true, // Auto-reconnect (default: true)
    network: 'mainnet-beta', // Initial network
    enableMobile: true, // Mobile Wallet Adapter (default: true)
    debug: false, // Debug logging

    // NEW: Custom error handler
    onError: (error, errorInfo) => {
        console.error('Connector error:', error);
        errorTracker.captureException(error, errorInfo);
    },
});

const config = getDefaultConfig({
    appName: 'My App',
    network: 'devnet', // 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet'
});

import { getDefaultConfig, createSolanaMainnet } from '@solana/connector';

const config = getDefaultConfig({
    appName: 'My App',
    clusters: [
        createSolanaMainnet({
            endpoint: 'https://my-custom-rpc.com',
        }),
    ],
    customClusters: [
        // Add additional custom clusters
    ],
});

<ConnectorProvider
  config={config}
  mobile={{
    appIdentity: {
      name: 'My App',
      uri: 'https://myapp.com',
      icon: 'https://myapp.com/icon.png'
    }
  }}
>
  <App />
</ConnectorProvider>

import { ConnectorClient, getDefaultConfig } from '@solana/connector/headless';

// Create client
const client = new ConnectorClient(getDefaultConfig({ appName: 'My App' }));

// Get state
const state = client.getSnapshot();
console.log('Wallets:', state.wallets);

// Connect
await client.select('Phantom');

// Subscribe to changes
const unsubscribe = client.subscribe(state => {
    console.log('State updated:', state);
});

// Subscribe to events (NEW!)
const unsubEvents = client.on(event => {
    console.log('Event:', event.type, event);
});

// Check health (NEW!)
const health = client.getHealth();
console.log('Health:', health);

// Disconnect
await client.disconnect();

// Cleanup
client.destroy();

import { createConfig, AppProvider } from '@solana/connector';
import { ArmaProvider } from '@armadura/sdk';

const config = createConfig({
  appName: 'My App',
  network: 'mainnet',
  rpcUrl: 'https://my-custom-rpc.com',
  autoConnect: true
});

function App() {
  return (
    <AppProvider config={config.connectorConfig}>
      <ArmaProvider
        config={{
          network: config.network,
          rpcUrl: config.rpcUrl,
          providers: [/* ... */]
        }}
        useConnector="auto"
      >
        {children}
      </ArmaProvider>
    </AppProvider>
  );
}

import { getDefaultConfig, createEnhancedStorageWallet, EnhancedStorageAdapter } from '@solana/connector';

const config = getDefaultConfig({
    appName: 'My App',

    storage: {
        wallet: new EnhancedStorageAdapter(
            createEnhancedStorageWallet({
                validator: walletName => {
                    // Custom validation
                    return walletName !== null && walletName.length > 0;
                },
                onError: error => {
                    Sentry.captureException(error);
                },
            }),
        ),
        // account and cluster use defaults if not specified
    },
});

// Full library - includes React and headless
import { ConnectorProvider, useConnector } from '@solana/connector';

// Headless core only - no React
import { ConnectorClient, getDefaultConfig } from '@solana/connector/headless';

// React-specific exports only
import { useConnector, useAccount } from '@solana/connector/react';

// Wallet adapter compatibility bridge
import { createWalletAdapterCompat } from '@solana/connector/compat';

import { describe, it, expect } from 'vitest';
import { StateManager } from './state-manager';

describe('StateManager', () => {
    it('should update state correctly', () => {
        const manager = new StateManager(initialState);
        manager.updateState({ connected: true });

        expect(manager.getSnapshot().connected).toBe(true);
    });
});

import { renderHook } from '@testing-library/react';
import { useAccount } from './use-account';
import { createHookWrapper } from '../__tests__/utils/react-helpers';

describe('useAccount', () => {
    it('should return account information', () => {
        const { result } = renderHook(() => useAccount(), {
            wrapper: createHookWrapper(),
        });

        expect(result.current.address).toBeDefined();
    });
});

import { createMockPhantomWallet, createMockSolflareWallet } from '../mocks/wallet-standard-mock';

const wallet = createMockPhantomWallet({
    connectBehavior: 'success', // or 'error', 'timeout'
});

import { createTestAccounts, TEST_ADDRESSES } from '../fixtures/accounts';
import { createTestWallets } from '../fixtures/wallets';

const accounts = createTestAccounts(3);
const wallets = createTestWallets();

import { waitForCondition, createEventCollector } from '../utils/test-helpers';

// Wait for a condition
await waitForCondition(() => state.connected, { timeout: 5000 });

// Collect events
const collector = createEventCollector();
client.on(collector.collect);
collector.assertEventEmitted('connected');

const config = getDefaultConfig({
  appName: string,                        // Required: App name
  appUrl?: string,                        // App URL for metadata
  autoConnect?: boolean,                  // Auto-reconnect (default: true)
  debug?: boolean,                        // Debug logging
  network?: 'mainnet' | 'mainnet-beta'    // Initial network (default: mainnet-beta)
    | 'devnet' | 'testnet' | 'localnet',
  enableMobile?: boolean,                 // Mobile Wallet Adapter (default: true)
  storage?: ConnectorConfig['storage'],   // Custom storage adapters
  clusters?: SolanaCluster[],             // Override default clusters
  customClusters?: SolanaCluster[],       // Add custom clusters
  persistClusterSelection?: boolean,      // Persist cluster (default: true)
  enableErrorBoundary?: boolean,          // Error boundaries (default: true)
  maxRetries?: number,                    // Retry attempts (default: 3)
  onError?: (error, errorInfo) => void    // Error handler (NEW!)
});

interface UseTransactionSignerReturn {
    signer: TransactionSigner | null; // Signer instance
    ready: boolean; // Whether signer is ready
    address: string | null; // Current address
    capabilities: TransactionSignerCapabilities; // What signer can do
}

import { createTransactionSigner } from '@solana/connector/headless';

const signer = createTransactionSigner({
    wallet: connectedWallet,
    account: selectedAccount,
    cluster: currentCluster, // Optional
});

interface TransactionSigner {
    readonly address: string;

    signTransaction(tx: any): Promise<any>;
    signAllTransactions(txs: any[]): Promise<any[]>;
    signAndSendTransaction(tx: any, options?: SendOptions): Promise<string>;
    signAndSendTransactions(txs: any[], options?: SendOptions): Promise<string[]>;
    signMessage?(message: Uint8Array): Promise<Uint8Array>;

    getCapabilities(): TransactionSignerCapabilities;
}

type ConnectorEvent =
    | { type: 'wallet:connected'; wallet: string; account: string; timestamp: string }
    | { type: 'wallet:disconnected'; timestamp: string }
    | { type: 'cluster:changed'; cluster: string; previousCluster: string | null; timestamp: string }
    | { type: 'wallets:detected'; count: number; timestamp: string }
    | { type: 'connecting'; wallet: string; timestamp: string }
    | { type: 'connection:failed'; wallet: string; error: string; timestamp: string }
    | { type: 'error'; error: Error; context: string; timestamp: string };

// Subscribe to events
const unsubscribe = client.on(event => {
    console.log('Event:', event.type, event);
});

// Unsubscribe
client.off(listener);

// Unsubscribe all
client.offAll();

interface ConnectorHealth {
    initialized: boolean;
    walletStandardAvailable: boolean;
    storageAvailable: boolean;
    walletsDetected: number;
    errors: string[];
    connectionState: {
        connected: boolean;
        connecting: boolean;
        hasSelectedWallet: boolean;
        hasSelectedAccount: boolean;
    };
    timestamp: string;
}

// Get health status
const health = client.getHealth();

class ConnectionPool {
    get(cluster: SolanaCluster): ConnectionLike;
    has(clusterId: string): boolean;
    clear(clusterId: string): void;
    clearAll(): void;
    getStats(): ConnectionPoolStats;
    resetStats(): void;
}

// Create pool
const pool = createConnectionPool(options);

// Get global pool
const pool = getConnectionPool();

// Create wallet-adapter compatible interface
createWalletAdapterCompat(
  signer: TransactionSigner | null,
  options: {
    disconnect: () => Promise<void>;
    transformTransaction?: (tx: any) => any;
    onError?: (error: Error, operation: string) => void;
  }
): WalletAdapterCompatible

// React hook version
useWalletAdapterCompat(
  signer: TransactionSigner | null,
  disconnect: () => Promise<void>,
  options?: Omit<WalletAdapterCompatOptions, 'disconnect'>
): WalletAdapterCompatible

// Type guard
isWalletAdapterCompatible(obj: any): obj is WalletAdapterCompatible

import {
    installPolyfills,
    isPolyfillInstalled,
    isCryptoAvailable,
    getPolyfillStatus,
} from '@solana/connector/headless';

// Install browser polyfills (automatic in React provider)
installPolyfills();

// Check status
const installed = isPolyfillInstalled();
const cryptoAvailable = isCryptoAvailable();
const status = getPolyfillStatus();

import { formatSOL, formatAddress } from '@solana/connector';

// Format SOL amounts
formatSOL(1500000000, { decimals: 4 }); // "1.5000 SOL"

// Format addresses
formatAddress(address, { length: 6 }); // "5Gv8yU...8x3kF"

// Lightweight versions (smaller bundle, no Intl)
import { formatSOLSimple, formatAddressSimple } from '@solana/connector';

import { copyAddressToClipboard, copyToClipboard } from '@solana/connector';

await copyAddressToClipboard(address);
await copyToClipboard(text);

import {
    getClusterRpcUrl,
    getClusterExplorerUrl,
    getTransactionUrl,
    getAddressUrl,
    isMainnetCluster,
    isDevnetCluster,
} from '@solana/connector';

const rpcUrl = getClusterRpcUrl(cluster);
const explorerUrl = getClusterExplorerUrl(cluster);
const txUrl = getTransactionUrl(cluster, signature);
const addrUrl = getAddressUrl(cluster, address);

import type {
    // Configuration
    ConnectorConfig,
    DefaultConfigOptions,
    ExtendedConnectorConfig,
    UnifiedConfig,
    MobileWalletAdapterConfig,

    // State & Info
    ConnectorState,
    ConnectorSnapshot,
    WalletInfo,
    AccountInfo,
    ConnectorHealth, // NEW!

    // Events
    ConnectorEvent, // NEW!
    ConnectorEventListener, // NEW!

    // Transaction Signing
    TransactionSigner, // NEW!
    TransactionSignerConfig, // NEW!
    TransactionSignerCapabilities, // NEW!
    SignedTransaction, // NEW!

    // Connection Pooling
    ConnectionLike, // NEW!
    ConnectionPoolOptions, // NEW!
    ConnectionPoolStats, // NEW!

    // Wallet Adapter Compat
    WalletAdapterCompatible, // NEW!
    WalletAdapterCompatOptions, // NEW!

    // Wallet Standard
    Wallet,
    WalletAccount,

    // Clusters
    SolanaCluster,
    SolanaClusterId,

    // Storage
    StorageAdapter,

    // Hook Returns
    UseClusterReturn,
    UseAccountReturn,
    UseWalletInfoReturn,
    UseTransactionSignerReturn, // NEW!

    // Errors
    WalletError,
} from '@solana/connector';

// Before (wallet-adapter)
import { useWallet } from '@solana/wallet-adapter-react';

const { publicKey, sendTransaction } = useWallet();
await sendTransaction(tx, connection);

// After (connector-kit)
import { useTransactionSigner } from '@solana/connector';

const { signer } = useTransactionSigner();
await signer.signAndSendTransaction(tx);

// Or use compatibility bridge for existing integrations
import { createWalletAdapterCompat } from '@solana/connector/compat';

const walletAdapter = createWalletAdapterCompat(signer, { disconnect });
// Pass walletAdapter to existing wallet-adapter code