@solana/connector 0.1.6 → 0.1.8

package/dist/headless.d.ts

@@ -1,22 +1,25 @@
-import { i as ClusterType, B as StorageOptions, S as StorageAdapter, F as EnhancedStorageAccountOptions, G as EnhancedStorageClusterOptions, H as EnhancedStorageWalletOptions } from './wallet-standard-shim--YcrQNRt.js';
-export { q as AccountAddress, A as AccountInfo, T as ClipboardErrorType, V as ClipboardResult, j as ConnectorClient, d as ConnectorConfig, v as ConnectorDebugMetrics, x as ConnectorDebugState, y as ConnectorEvent, z as ConnectorEventListener, t as ConnectorHealth, e as ConnectorState, X as CopyOptions, R as CreateSolanaClientArgs, D as DefaultConfigOptions, E as ExtendedConnectorConfig, L as Listener, M as MobileWalletAdapterConfig, P as ModifiedClusterUrl, af as PUBLIC_RPC_ENDPOINTS, Q as SolanaClient, O as SolanaClusterMoniker, ae as SolanaNetwork, h as UnifiedConfig, U as UnifiedConfigOptions, J as WalletError, I as WalletErrorType, W as WalletInfo, p as WalletName, g as WalletStandardAccount, f as WalletStandardWallet, _ as copyAddressToClipboard, $ as copySignatureToClipboard, Z as copyToClipboard, n as createConfig, N as createSolanaClient, a3 as getAddressUrl, a5 as getBlockUrl, ad as getChainIdForWalletStandard, ac as getClusterChainId, a1 as getClusterExplorerUrl, aa as getClusterName, a0 as getClusterRpcUrl, ab as getClusterType, l as getDefaultConfig, m as getDefaultMobileConfig, ai as getDefaultRpcUrl, an as getNetworkDisplayName, K as getPublicSolanaRpcUrl, a4 as getTokenUrl, a2 as getTransactionUrl, k as getWalletsRegistry, s as isAccountAddress, Y as isClipboardAvailable, ak as isDevnet, a7 as isDevnetCluster, a9 as isLocalCluster, am as isLocalnet, aj as isMainnet, a6 as isMainnetCluster, al as isTestnet, a8 as isTestnetCluster, o as isUnifiedConfig, r as isWalletName, ag as normalizeNetwork, ah as toClusterId } from './wallet-standard-shim--YcrQNRt.js';
-import { j as TransactionSigner } from './transaction-signer-D9d8nxwb.js';
-export { l as ConfigurationError, x as ConfigurationErrorCode, k as ConnectionError, v as ConnectionErrorCode, C as ConnectorError, E as Errors, N as NetworkError, y as NetworkErrorCode, a as SignedTransaction, S as SolanaTransaction, c as TransactionActivity, d as TransactionActivityStatus, m as TransactionError, z as TransactionErrorCode, f as TransactionMetadata, e as TransactionMethod, b as TransactionSignerCapabilities, T as TransactionSignerConfig, h as TransactionSignerError, V as ValidationError, w as ValidationErrorCode, g as createTransactionSigner, u as getUserFriendlyMessage, q as isConfigurationError, o as isConnectionError, n as isConnectorError, r as isNetworkError, s as isTransactionError, i as isTransactionSignerError, p as isValidationError, t as toConnectorError } from './transaction-signer-D9d8nxwb.js';
-import { TransactionModifyingSigner, MessageModifyingSigner, TransactionSendingSigner, SignatureDictionary } from '@solana/signers';
-export { MessageModifyingSigner, MessageModifyingSignerConfig, SignableMessage, SignatureDictionary, TransactionSendingSigner, TransactionSendingSignerConfig, createSignableMessage } from '@solana/signers';
+import { h as ClusterType, N as StorageOptions, K as StorageAdapter, O as EnhancedStorageAccountOptions, P as EnhancedStorageClusterOptions, Q as EnhancedStorageWalletOptions } from './standard-shim-D9guL5fz.js';
+export { x as AccountAddress, A as AccountInfo, R as ClipboardErrorType, T as ClipboardResult, B as CoinGeckoConfig, i as ConnectorClient, d as ConnectorConfig, G as ConnectorDebugMetrics, H as ConnectorDebugState, I as ConnectorEvent, J as ConnectorEventListener, F as ConnectorHealth, e as ConnectorState, U as CopyOptions, t as CreateSolanaClientArgs, D as DefaultConfigOptions, E as ExtendedConnectorConfig, L as Listener, M as MobileWalletAdapterConfig, q as ModifiedClusterUrl, s as SolanaClient, S as SolanaClusterMoniker, n as WalletError, m as WalletErrorType, W as WalletInfo, v as WalletName, g as WalletStandardAccount, f as WalletStandardWallet, Y as copyAddressToClipboard, Z as copySignatureToClipboard, X as copyToClipboard, p as createSolanaClient, a1 as getAddressUrl, a3 as getBlockUrl, ab as getChainIdForWalletStandard, aa as getClusterChainId, $ as getClusterExplorerUrl, a8 as getClusterName, _ as getClusterRpcUrl, a9 as getClusterType, j as getDefaultConfig, k as getDefaultMobileConfig, o as getPublicSolanaRpcUrl, a2 as getTokenUrl, a0 as getTransactionUrl, l as getWalletsRegistry, z as isAccountAddress, V as isClipboardAvailable, a5 as isDevnetCluster, a7 as isLocalCluster, a4 as isMainnetCluster, a6 as isTestnetCluster, y as isWalletName, r as ready } from './standard-shim-D9guL5fz.js';
+import { z } from 'zod/v4';
+import { a as TransactionSigner } from './transaction-signer-T-KVQFi8.js';
+export { d as ConfigurationError, p as ConfigurationErrorCode, b as ConnectionError, n as ConnectionErrorCode, C as ConnectorError, E as Errors, N as NetworkError, q as NetworkErrorCode, u as SignedTransaction, S as SolanaTransaction, w as TransactionActivity, x as TransactionActivityStatus, e as TransactionError, r as TransactionErrorCode, z as TransactionMetadata, y as TransactionMethod, v as TransactionSignerCapabilities, s as TransactionSignerConfig, T as TransactionSignerError, V as ValidationError, o as ValidationErrorCode, c as createTransactionSigner, m as getUserFriendlyMessage, j as isConfigurationError, g as isConnectionError, f as isConnectorError, k as isNetworkError, l as isTransactionError, i as isTransactionSignerError, h as isValidationError, t as toConnectorError } from './transaction-signer-T-KVQFi8.js';
 import { SolanaCluster, SolanaClusterId, Storage } from '@wallet-ui/core';
 export { SolanaCluster, SolanaClusterId, createSolanaDevnet, createSolanaLocalnet, createSolanaMainnet, createSolanaTestnet } from '@wallet-ui/core';
+import { Connection, SendOptions } from '@solana/web3.js';
+import { MessageModifyingSigner, TransactionSendingSigner, SignatureDictionary, TransactionModifyingSigner } from '@solana/signers';
+export { MessageModifyingSigner, MessageModifyingSignerConfig, SignableMessage, SignatureDictionary, TransactionSendingSigner, TransactionSendingSignerConfig, createSignableMessage } from '@solana/signers';
+import { TransactionMessage, TransactionMessageWithFeePayer, Rpc, GetLatestBlockhashApi, TransactionMessageWithBlockhashLifetime } from '@solana/kit';
 import { Address } from '@solana/addresses';
 export { Address, address } from '@solana/addresses';
 import { SignatureBytes } from '@solana/keys';
 export { SignatureBytes } from '@solana/keys';
+import { Transaction } from '@solana/transactions';
 export { Transaction } from '@solana/transactions';
 import { Wallet, WalletAccount } from '@wallet-standard/base';
 export { Wallet, WalletAccount } from '@wallet-standard/base';
-import { Connection, SendOptions } from '@solana/web3.js';
-import { TransactionMessage, TransactionMessageWithFeePayer, Rpc, GetLatestBlockhashApi, TransactionMessageWithBlockhashLifetime } from '@solana/kit';
-import 'react';
 import 'react/jsx-runtime';
+import 'react';
+import '@solana-mobile/wallet-standard-mobile';
 import '@solana/transaction-messages';
 
 /**
@@ -93,6 +96,91 @@ declare function formatTokenAmount(amount: number | bigint, decimals: number, op
     minimumDecimals?: number;
     maximumDecimals?: number;
 }): string;
+/**
+ * Format a bigint balance with decimals, avoiding Number precision loss.
+ * Uses string manipulation for precision beyond Number.MAX_SAFE_INTEGER.
+ *
+ * @param amount - The bigint amount in smallest units
+ * @param decimals - Number of decimal places for the token
+ * @param options - Formatting options
+ * @returns Formatted string representation
+ *
+ * @example
+ * // Small amounts (uses Number for speed)
+ * formatBigIntBalance(1000000n, 6) // Returns: '1'
+ *
+ * @example
+ * // Large amounts (uses string manipulation for precision)
+ * formatBigIntBalance(12345678901234567890n, 18) // Returns: '12.345678901234567890'
+ *
+ * @example
+ * // With options
+ * formatBigIntBalance(1500000n, 6, { maxDecimals: 2 }) // Returns: '1.5'
+ */
+declare function formatBigIntBalance(amount: bigint, decimals: number, options?: {
+    /** Maximum number of decimal places to show (default: min(decimals, 6)) */
+    maxDecimals?: number;
+    /** Minimum number of decimal places to show (default: 0) */
+    minDecimals?: number;
+    /** Locale for number formatting (default: undefined, uses browser locale) */
+    locale?: string;
+    /** Whether to use grouping separators like commas (default: true) */
+    useGrouping?: boolean;
+}): string;
+/**
+ * Convert lamports to SOL string representation with BigInt safety.
+ *
+ * @param lamports - Amount in lamports (bigint)
+ * @param options - Formatting options
+ * @returns Formatted SOL string
+ *
+ * @example
+ * formatLamportsToSolSafe(1000000000n) // Returns: '1'
+ * formatLamportsToSolSafe(1500000000n, { maxDecimals: 4 }) // Returns: '1.5'
+ * formatLamportsToSolSafe(1000000000n, { suffix: true }) // Returns: '1 SOL'
+ */
+declare function formatLamportsToSolSafe(lamports: bigint, options?: {
+    /** Maximum decimal places (default: 4) */
+    maxDecimals?: number;
+    /** Minimum decimal places (default: 0) */
+    minDecimals?: number;
+    /** Add ' SOL' suffix (default: false) */
+    suffix?: boolean;
+    /** Locale for formatting */
+    locale?: string;
+}): string;
+/**
+ * Format USD value from bigint amount with BigInt safety.
+ * Uses the USD price to calculate the value.
+ *
+ * @param amount - Token amount in smallest units (bigint)
+ * @param decimals - Token decimals
+ * @param usdPrice - Current USD price per token
+ * @param options - Formatting options
+ * @returns Formatted USD string
+ *
+ * @example
+ * formatBigIntUsd(1000000000n, 9, 150.50) // Returns: '$150.50'
+ */
+declare function formatBigIntUsd(amount: bigint, decimals: number, usdPrice: number, options?: {
+    /** Locale for formatting (default: undefined) */
+    locale?: string;
+    /** Currency code (default: 'USD') */
+    currency?: string;
+}): string;
+/**
+ * Format a token balance for display with BigInt safety.
+ * Convenience wrapper around formatBigIntBalance.
+ *
+ * @param amount - Token amount in smallest units
+ * @param decimals - Token decimals
+ * @param options - Formatting options
+ * @returns Formatted balance string
+ */
+declare function formatTokenBalanceSafe(amount: bigint, decimals: number, options?: {
+    maxDecimals?: number;
+    locale?: string;
+}): string;
 
 declare const SOLANA_CHAIN_IDS: {
     readonly mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
@@ -113,6 +201,113 @@ declare function clusterToChainId(cluster: SolanaCluster): `solana:${string}` |
 declare function chainIdToClusterType(chainId: string): ClusterType | null;
 declare function chainIdToClusterId(chainId: string): SolanaClusterId | null;
 
+/**
+ * @solana/connector - Network utilities
+ *
+ * Utilities for translating between different Solana network naming conventions.
+ * Ensures compatibility with WalletUI (SolanaClusterId) and Gill types.
+ *
+ * Primary type: SolanaNetwork - normalized network names
+ * External integration: Use WalletUI's SolanaClusterId for cluster operations
+ */
+
+/**
+ * Normalized Solana network names
+ *
+ * This is the canonical network type used throughout the connector.
+ * Use `toClusterId()` to convert to WalletUI's SolanaClusterId format.
+ * Aligned with Gill's SolanaClusterMoniker type.
+ */
+type SolanaNetwork = 'mainnet' | 'devnet' | 'testnet' | 'localnet';
+/**
+ * Public RPC endpoints for each Solana network
+ *
+ * ⚠️ WARNING: These are public, rate-limited endpoints provided by Solana Labs.
+ * For production applications, use a dedicated RPC provider like:
+ * - Triton (https://triton.one)
+ * - Helius (https://helius.dev)
+ * - QuickNode (https://quicknode.com)
+ * - Alchemy (https://alchemy.com)
+ *
+ * Note: These values are now sourced from Gill's getPublicSolanaRpcUrl for consistency.
+ * Kept here for reference and backward compatibility.
+ */
+declare const PUBLIC_RPC_ENDPOINTS: Record<SolanaNetwork, string>;
+/**
+ * Normalize network name to standard format
+ * Accepts various naming conventions and returns the canonical SolanaNetwork format
+ *
+ * @example
+ * normalizeNetwork('mainnet-beta') // Returns: 'mainnet'
+ * normalizeNetwork('mainnet') // Returns: 'mainnet'
+ * normalizeNetwork('MAINNET') // Returns: 'mainnet'
+ */
+declare function normalizeNetwork(network: string): SolanaNetwork;
+/**
+ * Convert network name to WalletUI cluster ID format
+ *
+ * WalletUI uses the 'solana:network' format for cluster identification.
+ *
+ * @example
+ * toClusterId('mainnet') // Returns: 'solana:mainnet'
+ * toClusterId('mainnet-beta') // Returns: 'solana:mainnet' (normalized)
+ */
+declare function toClusterId(network: string): SolanaClusterId;
+/**
+ * Get the public RPC URL for a network
+ *
+ * ⚠️ Returns public, rate-limited endpoints. For production, use a dedicated RPC provider.
+ *
+ * Now uses Gill's getPublicSolanaRpcUrl for consistency with the Gill ecosystem.
+ * Falls back to localnet URL for unknown networks.
+ *
+ * @example
+ * getDefaultRpcUrl('mainnet') // Returns: 'https://api.mainnet-beta.solana.com'
+ * getDefaultRpcUrl('devnet') // Returns: 'https://api.devnet.solana.com'
+ */
+declare function getDefaultRpcUrl(network: string): string;
+/**
+ * Check if a network is mainnet
+ *
+ * @example
+ * isMainnet('mainnet') // Returns: true
+ * isMainnet('mainnet-beta') // Returns: true
+ * isMainnet('devnet') // Returns: false
+ */
+declare function isMainnet(network: string): boolean;
+/**
+ * Check if a network is devnet
+ *
+ * @example
+ * isDevnet('devnet') // Returns: true
+ * isDevnet('mainnet') // Returns: false
+ */
+declare function isDevnet(network: string): boolean;
+/**
+ * Check if a network is testnet
+ *
+ * @example
+ * isTestnet('testnet') // Returns: true
+ * isTestnet('mainnet') // Returns: false
+ */
+declare function isTestnet(network: string): boolean;
+/**
+ * Check if a network is localnet
+ *
+ * @example
+ * isLocalnet('localnet') // Returns: true
+ * isLocalnet('mainnet') // Returns: false
+ */
+declare function isLocalnet(network: string): boolean;
+/**
+ * Get a user-friendly display name for a network
+ *
+ * @example
+ * getNetworkDisplayName('mainnet-beta') // Returns: 'Mainnet'
+ * getNetworkDisplayName('devnet') // Returns: 'Devnet'
+ */
+declare function getNetworkDisplayName(network: string): string;
+
 /**
  * @solana/connector - Kit Constants
  *
@@ -237,48 +432,218 @@ interface PrepareTransactionConfig<TMessage extends PrepareCompilableTransaction
 declare function prepareTransaction<TMessage extends PrepareCompilableTransactionMessage>(config: PrepareTransactionConfig<TMessage>): Promise<TMessage & TransactionMessageWithBlockhashLifetime>;
 
 /**
- * @solana/connector - Kit Transaction Signer Adapter
+ * @solana/connector - Kit Signer Factories
  *
- * Adapter that wraps connector-kit's TransactionSigner to be compatible with
- * @solana/kit TransactionModifyingSigner interface.
+ * Framework-agnostic factory functions to create Kit-compatible signers from wallet functions.
+ * These factories enable pure Kit integration without React or framework dependencies.
+ */
+
+/**
+ * Create a MessageModifyingSigner from a wallet's sign message function
  *
- * This enables connector-kit to work seamlessly with modern Solana libraries
- * that expect @solana/kit's signer interface.
+ * This is a pure, framework-agnostic factory function that can be used anywhere.
+ * Enables message signing (SIWS, auth) without React.
  *
- * Uses TransactionModifyingSigner to return fully signed Transaction objects,
- * ensuring the exact bytes the wallet signed are preserved without re-encoding.
+ * @param walletAddress - The address of the wallet
+ * @param signMessageFn - Function to sign a message (from wallet adapter)
+ * @returns A frozen MessageModifyingSigner object
+ *
+ * @example
+ * ```typescript
+ * import { address } from '@solana/addresses';
+ * import { createMessageSignerFromWallet } from '@solana/connector/headless';
+ *
+ * const signer = createMessageSignerFromWallet(
+ *   address('...'),
+ *   async (msg) => await wallet.signMessage(msg)
+ * );
+ *
+ * // Use with Kit message signing
+ * import { createSignableMessage } from '@solana/signers';
+ * const signed = await signer.modifyAndSignMessages([createSignableMessage(messageBytes)]);
+ * ```
  */
+declare function createMessageSignerFromWallet(walletAddress: Address<string>, signMessageFn: (message: Uint8Array) => Promise<Uint8Array>): MessageModifyingSigner<string>;
+/**
+ * Create a TransactionSendingSigner from a wallet's send transaction function
+ *
+ * This is a pure, framework-agnostic factory function that can be used anywhere.
+ * Enables sign + send in one operation (wallets like Phantom support this).
+ *
+ * @param walletAddress - The address of the wallet
+ * @param chain - The Solana chain identifier (e.g., 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1')
+ * @param sendTransactionFn - Function to send a transaction (from wallet adapter)
+ * @returns A frozen TransactionSendingSigner object
+ *
+ * @example
+ * ```typescript
+ * import { address } from '@solana/addresses';
+ * import { createTransactionSendingSignerFromWallet } from '@solana/connector/headless';
+ *
+ * const signer = createTransactionSendingSignerFromWallet(
+ *   address('...'),
+ *   'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+ *   async (tx) => await wallet.sendTransaction(tx, connection)
+ * );
+ *
+ * // Use with Kit transaction sending
+ * const signatures = await signer.signAndSendTransactions([transaction]);
+ * ```
+ */
+declare function createTransactionSendingSignerFromWallet(walletAddress: Address<string>, chain: `solana:${string}`, sendTransactionFn: (transaction: Transaction) => Promise<string>): TransactionSendingSigner<string>;
 
 /**
- * Create a kit-compatible TransactionPartialSigner from connector-kit's TransactionSigner
+ * @solana/connector - Kit Integration Helper
  *
- * This adapter allows connector-kit to work with modern Solana libraries that use
- * @solana/kit's signer interfaces.
+ * High-level helper to create Kit signers from Wallet Standard wallets.
+ * Framework-agnostic and works in any JavaScript environment.
+ */
+
+/**
+ * Result of creating Kit signers from a Wallet Standard wallet
+ */
+interface KitSignersFromWallet {
+    /** Kit Address type (null if wallet not connected) */
+    address: Address<string> | null;
+    /** Plain address string (null if wallet not connected) */
+    addressString: string | null;
+    /** Message signer (null if wallet doesn't support signing or not connected) */
+    messageSigner: MessageModifyingSigner<string> | null;
+    /** Transaction sending signer (null if wallet doesn't support or not connected) */
+    transactionSigner: TransactionSendingSigner<string> | null;
+}
+/**
+ * Create Kit-compatible signers from a Wallet Standard wallet
  *
- * @param connectorSigner - Connector-kit's TransactionSigner instance
- * @returns Kit-compatible TransactionModifyingSigner
+ * This function bridges Wallet Standard wallets with modern Kit architecture.
+ * It's framework-agnostic and can be used in any JavaScript environment.
+ *
+ * The network is automatically detected from the connection's RPC endpoint.
+ * For custom RPC URLs, you can override detection with the optional `network` parameter.
+ *
+ * @param wallet - The Wallet Standard wallet instance
+ * @param account - The wallet account to use (first account if not provided)
+ * @param connection - Optional connection for network detection and transaction sending
+ * @param network - Optional network override ('mainnet' | 'devnet' | 'testnet')
+ * @returns Kit signers object with address and signer instances
  *
  * @example
  * ```typescript
- * import { createTransactionSigner } from '@solana/connector';
- * import { createKitTransactionSigner } from '@solana/connector';
+ * import { Connection } from '@solana/web3.js';
+ * import { createKitSignersFromWallet } from '@solana/connector/headless';
  *
- * const connectorSigner = createTransactionSigner({ wallet, account });
- * const kitSigner = createKitTransactionSigner(connectorSigner);
+ * const connection = new Connection('https://api.devnet.solana.com');
+ * const { address, messageSigner, transactionSigner } = createKitSignersFromWallet(
+ *   wallet,
+ *   account,
+ *   connection
+ * );
+ * ```
+ */
+declare function createKitSignersFromWallet(wallet: Wallet | null, account?: WalletAccount | null, connection?: Connection | null, network?: 'mainnet' | 'devnet' | 'testnet'): KitSignersFromWallet;
+
+declare function detectMessageModification(original: Uint8Array, modified: Uint8Array): boolean;
+declare function updateSignatureDictionary(original: Uint8Array, signed: Uint8Array, originalSignatures: SignatureDictionary, address: Address<string>, signature: Uint8Array): SignatureDictionary;
+declare function freezeSigner<T extends object>(signer: T): Readonly<T>;
+declare function base58ToSignatureBytes(signature: string): SignatureBytes;
+declare function signatureBytesToBase58(bytes: SignatureBytes): string;
+
+/**
+ * @solana/connector - Configuration Schemas
  *
- * // Now compatible with @solana/kit libraries
- * const instruction = getTransferSolInstruction({
- *   source: kitSigner,
- *   destination: address('...'),
- *   amount: 1000000n
+ * Zod schemas for runtime validation of configuration options.
+ * These schemas provide type-safe validation with helpful error messages.
+ */
+
+declare const defaultConfigOptionsSchema: z.ZodObject<{
+    appName: z.ZodString;
+    appUrl: z.ZodOptional<z.ZodString>;
+    imageProxy: z.ZodOptional<z.ZodString>;
+    clusterStorageKey: z.ZodOptional<z.ZodString>;
+    autoConnect: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    enableMobile: z.ZodOptional<z.ZodBoolean>;
+    persistClusterSelection: z.ZodOptional<z.ZodBoolean>;
+    enableErrorBoundary: z.ZodOptional<z.ZodBoolean>;
+    network: z.ZodOptional<z.ZodEnum<{
+        devnet: "devnet";
+        localnet: "localnet";
+        mainnet: "mainnet";
+        testnet: "testnet";
+        "mainnet-beta": "mainnet-beta";
+    }>>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    storage: z.ZodOptional<z.ZodObject<{
+        account: z.ZodObject<{
+            get: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+            set: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        }, z.core.$loose>;
+        cluster: z.ZodObject<{
+            get: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+            set: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        }, z.core.$loose>;
+        wallet: z.ZodObject<{
+            get: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+            set: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+    clusters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        url: z.ZodString;
+        urlWs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    customClusters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        url: z.ZodString;
+        urlWs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    programLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    coingecko: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        isPro: z.ZodOptional<z.ZodBoolean>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        baseDelay: z.ZodOptional<z.ZodNumber>;
+        maxTimeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    onError: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+}, z.core.$strip>;
+type DefaultConfigOptionsInput = z.input<typeof defaultConfigOptionsSchema>;
+/**
+ * Validate configuration options and return a result with helpful errors
+ *
+ * @example
+ * ```ts
+ * const result = validateConfigOptions({
+ *   appName: 'My App',
+ *   network: 'mainnet',
  * });
+ *
+ * if (!result.success) {
+ *   console.error('Config validation failed:', result.error.format());
+ * }
  * ```
  */
-declare function createKitTransactionSigner<TAddress extends string = string>(connectorSigner: TransactionSigner): TransactionModifyingSigner<TAddress>;
+declare function validateConfigOptions(options: unknown): z.ZodSafeParseResult<DefaultConfigOptionsInput>;
 /**
- * @deprecated Use `createKitTransactionSigner` instead. This alias is provided for backward compatibility.
+ * Parse and validate config options, throwing on error with formatted message
+ *
+ * @throws {z.ZodError} If validation fails
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const validOptions = parseConfigOptions(userInput);
+ *   // validOptions is typed and validated
+ * } catch (error) {
+ *   if (error instanceof z.ZodError) {
+ *     console.error(error.format());
+ *   }
+ * }
+ * ```
  */
-declare const createGillTransactionSigner: typeof createKitTransactionSigner;
+declare function parseConfigOptions(options: unknown): DefaultConfigOptionsInput;
 
 /**
  * Enhanced Storage
@@ -324,6 +689,141 @@ declare class EnhancedStorageAdapter<T> implements StorageAdapter<T> {
     onError(handler: (error: Error) => void): this;
 }
 
+/**
+ * @solana/connector - Kit Transaction Signer Adapter
+ *
+ * Adapter that wraps connector-kit's TransactionSigner to be compatible with
+ * @solana/kit TransactionModifyingSigner interface.
+ *
+ * This enables connector-kit to work seamlessly with modern Solana libraries
+ * that expect @solana/kit's signer interface.
+ *
+ * Uses TransactionModifyingSigner to return fully signed Transaction objects,
+ * ensuring the exact bytes the wallet signed are preserved without re-encoding.
+ */
+
+/**
+ * Create a kit-compatible TransactionPartialSigner from connector-kit's TransactionSigner
+ *
+ * This adapter allows connector-kit to work with modern Solana libraries that use
+ * @solana/kit's signer interfaces.
+ *
+ * @param connectorSigner - Connector-kit's TransactionSigner instance
+ * @returns Kit-compatible TransactionModifyingSigner
+ *
+ * @example
+ * ```typescript
+ * import { createTransactionSigner } from '@solana/connector';
+ * import { createKitTransactionSigner } from '@solana/connector';
+ *
+ * const connectorSigner = createTransactionSigner({ wallet, account });
+ * const kitSigner = createKitTransactionSigner(connectorSigner);
+ *
+ * // Now compatible with @solana/kit libraries
+ * const instruction = getTransferSolInstruction({
+ *   source: kitSigner,
+ *   destination: address('...'),
+ *   amount: 1000000n
+ * });
+ * ```
+ */
+declare function createKitTransactionSigner<TAddress extends string = string>(connectorSigner: TransactionSigner): TransactionModifyingSigner<TAddress>;
+/**
+ * @deprecated Use `createKitTransactionSigner` instead. This alias is provided for backward compatibility.
+ */
+declare const createGillTransactionSigner: typeof createKitTransactionSigner;
+
+/**
+ * @solana/connector - Try-Catch Utility
+ *
+ * Provides a consistent pattern for async error handling,
+ * returning a Result type instead of throwing errors.
+ */
+/**
+ * Represents a failed operation
+ */
+interface Failure<E> {
+    data: null;
+    error: E;
+}
+/**
+ * Represents a successful operation
+ */
+interface Success<T> {
+    data: T;
+    error: null;
+}
+/**
+ * Result type that is either a Success or Failure
+ */
+type Result<T, E = Error> = Success<T> | Failure<E>;
+/**
+ * Wraps an async operation and returns a Result instead of throwing.
+ * This enables consistent error handling without nested try/catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A Result containing either the data or an error
+ *
+ * @example Basic usage
+ * ```typescript
+ * const { data, error } = await tryCatch(fetchData());
+ * if (error) {
+ *   console.error('Failed:', error.message);
+ *   return;
+ * }
+ * console.log('Success:', data);
+ * ```
+ *
+ * @example With typed errors
+ * ```typescript
+ * const { data, error } = await tryCatch<User, ApiError>(api.getUser(id));
+ * if (error) {
+ *   // error is typed as ApiError
+ *   handleApiError(error);
+ *   return;
+ * }
+ * // data is typed as User
+ * displayUser(data);
+ * ```
+ *
+ * @example Chaining operations
+ * ```typescript
+ * const { data: user, error: userError } = await tryCatch(getUser(id));
+ * if (userError) return handleError(userError);
+ *
+ * const { data: posts, error: postsError } = await tryCatch(getPosts(user.id));
+ * if (postsError) return handleError(postsError);
+ *
+ * return { user, posts };
+ * ```
+ */
+declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+/**
+ * Synchronous version of tryCatch for non-async operations
+ *
+ * @param fn - The function to execute
+ * @returns A Result containing either the return value or an error
+ *
+ * @example
+ * ```typescript
+ * const { data, error } = tryCatchSync(() => JSON.parse(jsonString));
+ * if (error) {
+ *   console.error('Invalid JSON:', error.message);
+ *   return defaultValue;
+ * }
+ * return data;
+ * ```
+ */
+declare function tryCatchSync<T, E = Error>(fn: () => T): Result<T, E>;
+/**
+ * Type guard to check if a Result is a Success
+ */
+declare function isSuccess<T, E>(result: Result<T, E>): result is Success<T>;
+/**
+ * Type guard to check if a Result is a Failure
+ */
+declare function isFailure<T, E>(result: Result<T, E>): result is Failure<E>;
+
 /**
  * @solana/connector - Browser Compatibility Polyfills
  *
@@ -407,124 +907,12 @@ declare function getPolyfillStatus(): {
     environment: 'browser' | 'server';
 };
 
-/**
- * @solana/connector - Kit Signer Factories
- *
- * Framework-agnostic factory functions to create Kit-compatible signers from wallet functions.
- * These factories enable pure Kit integration without React or framework dependencies.
- */
-
-/**
- * Create a MessageModifyingSigner from a wallet's sign message function
- *
- * This is a pure, framework-agnostic factory function that can be used anywhere.
- * Enables message signing (SIWS, auth) without React.
- *
- * @param walletAddress - The address of the wallet
- * @param signMessageFn - Function to sign a message (from wallet adapter)
- * @returns A frozen MessageModifyingSigner object
- *
- * @example
- * ```typescript
- * import { address } from '@solana/addresses';
- * import { createMessageSignerFromWallet } from '@solana/connector/headless';
- *
- * const signer = createMessageSignerFromWallet(
- *   address('...'),
- *   async (msg) => await wallet.signMessage(msg)
- * );
- *
- * // Use with Kit message signing
- * import { createSignableMessage } from '@solana/signers';
- * const signed = await signer.modifyAndSignMessages([createSignableMessage(messageBytes)]);
- * ```
- */
-declare function createMessageSignerFromWallet(walletAddress: Address<string>, signMessageFn: (message: Uint8Array) => Promise<Uint8Array>): MessageModifyingSigner<string>;
-/**
- * Create a TransactionSendingSigner from a wallet's send transaction function
- *
- * This is a pure, framework-agnostic factory function that can be used anywhere.
- * Enables sign + send in one operation (wallets like Phantom support this).
- *
- * @param walletAddress - The address of the wallet
- * @param chain - The Solana chain identifier (e.g., 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1')
- * @param sendTransactionFn - Function to send a transaction (from wallet adapter)
- * @returns A frozen TransactionSendingSigner object
- *
- * @example
- * ```typescript
- * import { address } from '@solana/addresses';
- * import { createTransactionSendingSignerFromWallet } from '@solana/connector/headless';
- *
- * const signer = createTransactionSendingSignerFromWallet(
- *   address('...'),
- *   'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
- *   async (tx) => await wallet.sendTransaction(tx, connection)
- * );
- *
- * // Use with Kit transaction sending
- * const signatures = await signer.signAndSendTransactions([transaction]);
- * ```
- */
-declare function createTransactionSendingSignerFromWallet(walletAddress: Address<string>, chain: `solana:${string}`, sendTransactionFn: (transaction: any) => Promise<string>): TransactionSendingSigner<string>;
-
-/**
- * @solana/connector - Kit Integration Helper
- *
- * High-level helper to create Kit signers from Wallet Standard wallets.
- * Framework-agnostic and works in any JavaScript environment.
- */
-
-/**
- * Result of creating Kit signers from a Wallet Standard wallet
- */
-interface KitSignersFromWallet {
-    /** Kit Address type (null if wallet not connected) */
-    address: Address<string> | null;
-    /** Plain address string (null if wallet not connected) */
-    addressString: string | null;
-    /** Message signer (null if wallet doesn't support signing or not connected) */
-    messageSigner: MessageModifyingSigner<string> | null;
-    /** Transaction sending signer (null if wallet doesn't support or not connected) */
-    transactionSigner: TransactionSendingSigner<string> | null;
-}
-/**
- * Create Kit-compatible signers from a Wallet Standard wallet
- *
- * This function bridges Wallet Standard wallets with modern Kit architecture.
- * It's framework-agnostic and can be used in any JavaScript environment.
- *
- * The network is automatically detected from the connection's RPC endpoint.
- * For custom RPC URLs, you can override detection with the optional `network` parameter.
- *
- * @param wallet - The Wallet Standard wallet instance
- * @param account - The wallet account to use (first account if not provided)
- * @param connection - Optional connection for network detection and transaction sending
- * @param network - Optional network override ('mainnet' | 'devnet' | 'testnet')
- * @returns Kit signers object with address and signer instances
- *
- * @example
- * ```typescript
- * import { Connection } from '@solana/web3.js';
- * import { createKitSignersFromWallet } from '@solana/connector/headless';
- *
- * const connection = new Connection('https://api.devnet.solana.com');
- * const { address, messageSigner, transactionSigner } = createKitSignersFromWallet(
- *   wallet,
- *   account,
- *   connection
- * );
- * ```
- */
-declare function createKitSignersFromWallet(wallet: Wallet | null, account?: WalletAccount | null, connection?: Connection | null, network?: 'mainnet' | 'devnet' | 'testnet'): KitSignersFromWallet;
-
-declare function detectMessageModification(original: Uint8Array, modified: Uint8Array): boolean;
-declare function updateSignatureDictionary(original: Uint8Array, signed: Uint8Array, originalSignatures: SignatureDictionary, address: Address<string>, signature: Uint8Array): SignatureDictionary;
-declare function freezeSigner<T extends object>(signer: T): Readonly<T>;
-declare function base58ToSignatureBytes(signature: string): SignatureBytes;
-declare function signatureBytesToBase58(bytes: SignatureBytes): string;
-
 type Commitment = 'processed' | 'confirmed' | 'finalized';
+interface KitSendTransactionOptions {
+    commitment?: Commitment;
+    skipPreflight?: boolean;
+    maxRetries?: number;
+}
 type KitRpc = {
     getLatestBlockhash(options?: {
         commitment?: Commitment;
@@ -536,7 +924,7 @@ type KitRpc = {
             };
         }>;
     };
-    sendTransaction(bytes: Uint8Array | string, options?: any): {
+    sendTransaction(bytes: Uint8Array | string, options?: KitSendTransactionOptions): {
         send(): Promise<string>;
     };
     send?: () => unknown;
@@ -640,4 +1028,4 @@ declare function formatSignature(signature: string, chars?: number): string;
  */
 declare function copySignature(signature: string): Promise<boolean>;
 
-export { ClusterType, type Commitment, type DualConnection, EnhancedStorage, EnhancedStorageAccountOptions, EnhancedStorageAdapter, EnhancedStorageClusterOptions, EnhancedStorageWalletOptions, type ExplorerOptions, type ExplorerType, type GetExplorerLinkArgs, type KitSignersFromWallet, LAMPORTS_PER_SOL, type PrepareTransactionConfig, SOLANA_CHAIN_IDS, StorageAdapter, StorageOptions, TransactionSigner, base58ToSignatureBytes, chainIdToClusterId, chainIdToClusterType, clusterToChainId, copySignature, createEnhancedStorageAccount, createEnhancedStorageCluster, createEnhancedStorageWallet, createGillTransactionSigner, createKitSignersFromWallet, createKitTransactionSigner, createMessageSignerFromWallet, createTransactionSendingSignerFromWallet, detectMessageModification, formatAddress, formatNumber, formatSOL, formatSignature, formatTokenAmount, freezeSigner, getAllExplorerUrls, getChainIdFromCluster, getChainIdFromClusterId, getChainIdFromClusterType, getChainIdFromConnection, getClusterIdFromChainId, getClusterTypeFromChainId, getClusterTypeFromConnection, getExplorerLink, getLatestBlockhash, getPolyfillStatus, getSolanaExplorerUrl, getSolanaFmUrl, getSolscanUrl, getXrayUrl, installPolyfills, isCryptoAvailable, isKitConnection, isKnownSolanaChain, isLegacyConnection, isPolyfillInstalled, isSolanaChain, lamportsToSol, prepareTransaction, sendRawTransaction, signatureBytesToBase58, solToLamports, truncate, updateSignatureDictionary, validateKnownSolanaChain };
+export { ClusterType, type Commitment, type DualConnection, EnhancedStorage, EnhancedStorageAccountOptions, EnhancedStorageAdapter, EnhancedStorageClusterOptions, EnhancedStorageWalletOptions, type ExplorerOptions, type ExplorerType, type Failure, type GetExplorerLinkArgs, type KitSignersFromWallet, LAMPORTS_PER_SOL, PUBLIC_RPC_ENDPOINTS, type PrepareTransactionConfig, type Result, SOLANA_CHAIN_IDS, type SolanaNetwork, StorageAdapter, StorageOptions, type Success, TransactionSigner, base58ToSignatureBytes, chainIdToClusterId, chainIdToClusterType, clusterToChainId, copySignature, createEnhancedStorageAccount, createEnhancedStorageCluster, createEnhancedStorageWallet, createGillTransactionSigner, createKitSignersFromWallet, createKitTransactionSigner, createMessageSignerFromWallet, createTransactionSendingSignerFromWallet, detectMessageModification, formatAddress, formatBigIntBalance, formatBigIntUsd, formatLamportsToSolSafe, formatNumber, formatSOL, formatSignature, formatTokenAmount, formatTokenBalanceSafe, freezeSigner, getAllExplorerUrls, getChainIdFromCluster, getChainIdFromClusterId, getChainIdFromClusterType, getChainIdFromConnection, getClusterIdFromChainId, getClusterTypeFromChainId, getClusterTypeFromConnection, getDefaultRpcUrl, getExplorerLink, getLatestBlockhash, getNetworkDisplayName, getPolyfillStatus, getSolanaExplorerUrl, getSolanaFmUrl, getSolscanUrl, getXrayUrl, installPolyfills, isCryptoAvailable, isDevnet, isFailure, isKitConnection, isKnownSolanaChain, isLegacyConnection, isLocalnet, isMainnet, isPolyfillInstalled, isSolanaChain, isSuccess, isTestnet, lamportsToSol, normalizeNetwork, parseConfigOptions, prepareTransaction, sendRawTransaction, signatureBytesToBase58, solToLamports, toClusterId, truncate, tryCatch, tryCatchSync, updateSignatureDictionary, validateConfigOptions, validateKnownSolanaChain };