@solana/connector 0.0.0 → 0.1.1

package/dist/headless.d.ts

@@ -0,0 +1,515 @@
+import { i as ClusterType, B as StorageOptions, S as StorageAdapter, F as EnhancedStorageAccountOptions, G as EnhancedStorageClusterOptions, H as EnhancedStorageWalletOptions } from './wallet-standard-shim-C1tisl9S.js';
+export { q as AccountAddress, A as AccountInfo, K as ClipboardErrorType, N 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, O as CopyOptions, D as DefaultConfigOptions, E as ExtendedConnectorConfig, L as Listener, M as MobileWalletAdapterConfig, a9 as PUBLIC_RPC_ENDPOINTS, a8 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, R as copyAddressToClipboard, T as copySignatureToClipboard, Q as copyToClipboard, n as createConfig, Z as getAddressUrl, $ as getBlockUrl, a7 as getChainIdForWalletStandard, a6 as getClusterChainId, X as getClusterExplorerUrl, a4 as getClusterName, V as getClusterRpcUrl, a5 as getClusterType, l as getDefaultConfig, m as getDefaultMobileConfig, ac as getDefaultRpcUrl, ah as getNetworkDisplayName, _ as getTokenUrl, Y as getTransactionUrl, k as getWalletsRegistry, s as isAccountAddress, P as isClipboardAvailable, ae as isDevnet, a1 as isDevnetCluster, a3 as isLocalCluster, ag as isLocalnet, ad as isMainnet, a0 as isMainnetCluster, af as isTestnet, a2 as isTestnetCluster, o as isUnifiedConfig, r as isWalletName, aa as normalizeNetwork, ab as toClusterId } from './wallet-standard-shim-C1tisl9S.js';
+import { j as TransactionSigner } from './transaction-signer-D3csM_Mf.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-D3csM_Mf.js';
+import { TransactionModifyingSigner } from 'gill';
+import { SolanaCluster, SolanaClusterId, Storage } from '@wallet-ui/core';
+export { SolanaCluster, SolanaClusterId, createSolanaDevnet, createSolanaLocalnet, createSolanaMainnet, createSolanaTestnet } from '@wallet-ui/core';
+import { MessageModifyingSigner, TransactionSendingSigner, SignatureDictionary } from '@solana/signers';
+export { MessageModifyingSigner, MessageModifyingSignerConfig, SignableMessage, SignatureDictionary, TransactionSendingSigner, TransactionSendingSignerConfig, createSignableMessage } from '@solana/signers';
+import { Address } from '@solana/addresses';
+export { Address, address } from '@solana/addresses';
+import { SignatureBytes } from '@solana/keys';
+export { SignatureBytes } from '@solana/keys';
+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 'react';
+import 'react/jsx-runtime';
+
+/**
+ * @solana/connector - Formatting utilities
+ *
+ * Unified utility functions for formatting addresses, amounts, and other display values
+ * Consolidates both fast (number-based) and precise (bigint-based) formatting options
+ */
+/**
+ * Format a Solana address for display
+ *
+ * @example
+ * formatAddress('7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU')
+ * // Returns: '7xKX...gAsU'
+ *
+ * @example
+ * formatAddress('7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU', { length: 6 })
+ * // Returns: '7xKXtg...osgAsU'
+ */
+declare function formatAddress(address: string, options?: {
+    length?: number;
+    separator?: string;
+}): string;
+/**
+ * Format SOL amount for display
+ * Supports both precise bigint and fast number arithmetic
+ *
+ * @param lamports - Amount in lamports (number or bigint)
+ * @param options - Formatting options
+ * @param options.decimals - Number of decimal places (default: 4)
+ * @param options.suffix - Add 'SOL' suffix (default: true)
+ * @param options.fast - Use fast number arithmetic for amounts < 9000 SOL (default: false)
+ *
+ * @example
+ * formatSOL(1000000000n) // Returns: '1.0000 SOL' (precise)
+ * formatSOL(1000000000, { fast: true }) // Returns: '1.0000 SOL' (fast)
+ * formatSOL(1500000000, { decimals: 2 }) // Returns: '1.50 SOL'
+ */
+declare function formatSOL(lamports: number | bigint, options?: {
+    decimals?: number;
+    suffix?: boolean;
+    fast?: boolean;
+}): string;
+/**
+ * Format a number with thousands separators
+ *
+ * @example
+ * formatNumber(1234567.89) // Returns: '1,234,567.89'
+ */
+declare function formatNumber(value: number, options?: {
+    decimals?: number;
+    locale?: string;
+}): string;
+/**
+ * Truncate text with ellipsis
+ *
+ * @param text - Text to truncate
+ * @param maxLength - Maximum length including ellipsis
+ * @param position - Where to truncate: 'middle' or 'end' (default: 'middle')
+ *
+ * @example
+ * truncate('Hello World', 8) // Returns: 'He...ld'
+ * truncate('Hello World', 8, 'end') // Returns: 'Hello...'
+ * truncate('Short', 10) // Returns: 'Short' (no truncation needed)
+ */
+declare function truncate(text: string, maxLength: number, position?: 'middle' | 'end'): string;
+/**
+ * Format token amount with proper decimals
+ *
+ * @example
+ * formatTokenAmount(1000000, 6) // Returns: '1.000000'
+ */
+declare function formatTokenAmount(amount: number | bigint, decimals: number, options?: {
+    minimumDecimals?: number;
+    maximumDecimals?: number;
+}): string;
+
+declare const SOLANA_CHAIN_IDS: {
+    readonly mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    readonly devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    readonly testnet: "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+};
+declare function getChainIdFromCluster(cluster: SolanaCluster): `solana:${string}` | null;
+declare function getChainIdFromClusterId(clusterId: SolanaClusterId): `solana:${string}` | null;
+declare function getChainIdFromClusterType(type: ClusterType): `solana:${string}` | null;
+declare function getClusterTypeFromChainId(chainId: string): ClusterType | null;
+declare function getClusterIdFromChainId(chainId: string): SolanaClusterId | null;
+declare function isSolanaChain(chain: string): chain is `solana:${string}`;
+declare function isKnownSolanaChain(chain: string): boolean;
+declare function validateKnownSolanaChain(chain: string): asserts chain is `solana:${string}`;
+declare function getClusterTypeFromConnection(connection: Connection | null): ClusterType | null;
+declare function getChainIdFromConnection(connection: Connection | null, network?: 'mainnet' | 'devnet' | 'testnet'): `solana:${string}` | null;
+declare function clusterToChainId(cluster: SolanaCluster): `solana:${string}` | null;
+declare function chainIdToClusterType(chainId: string): ClusterType | null;
+declare function chainIdToClusterId(chainId: string): SolanaClusterId | null;
+
+/**
+ * @solana/connector - Gill/Kit Transaction Signer Adapter
+ *
+ * Adapter that wraps connector-kit's TransactionSigner to be compatible with
+ * gill (@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 gill-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 (gill, etc.)
+ *
+ * @param connectorSigner - Connector-kit's TransactionSigner instance
+ * @returns Gill-compatible TransactionPartialSigner
+ *
+ * @example
+ * ```typescript
+ * import { createTransactionSigner } from '@solana/connector';
+ * import { createGillTransactionSigner } from '@solana/connector/gill';
+ *
+ * const connectorSigner = createTransactionSigner({ wallet, account });
+ * const gillSigner = createGillTransactionSigner(connectorSigner);
+ *
+ * // Now compatible with gill libraries
+ * const instruction = getTransferSolInstruction({
+ *   source: gillSigner,
+ *   destination: address('...'),
+ *   amount: 1000000n
+ * });
+ * ```
+ */
+declare function createGillTransactionSigner<TAddress extends string = string>(connectorSigner: TransactionSigner): TransactionModifyingSigner<TAddress>;
+
+/**
+ * Enhanced Storage
+ */
+
+/**
+ * Enhanced version of wallet-ui's Storage class
+ * Extends the base Storage with validation, error handling, and SSR support
+ */
+declare class EnhancedStorage<T> extends Storage<T> {
+    private options?;
+    private errorHandlers;
+    private validators;
+    private memoryFallback;
+    constructor(key: string, initial: T, options?: StorageOptions<T> | undefined);
+    set(value: T): boolean;
+    get(): T;
+    validate(value: T): boolean;
+    addValidator(validator: (value: T) => boolean): this;
+    onError(handler: (error: Error) => void): this;
+    transform<U>(transformer: (value: T) => U): U;
+    reset(): void;
+    clear(): void;
+    isAvailable(): boolean;
+    static migrate<T>(oldKey: string, newStorage: EnhancedStorage<T>): boolean;
+    private handleError;
+}
+declare function createEnhancedStorageAccount(options?: EnhancedStorageAccountOptions): EnhancedStorage<string | undefined>;
+declare function createEnhancedStorageCluster(options?: EnhancedStorageClusterOptions): EnhancedStorage<SolanaClusterId>;
+declare function createEnhancedStorageWallet(options?: EnhancedStorageWalletOptions): EnhancedStorage<string | undefined>;
+declare class EnhancedStorageAdapter<T> implements StorageAdapter<T> {
+    private storage;
+    constructor(storage: EnhancedStorage<T>);
+    get(): T;
+    set(value: T): void;
+    subscribe(callback: (value: T) => void): () => void;
+    validate(value: T): boolean;
+    reset(): void;
+    clear(): void;
+    isAvailable(): boolean;
+    transform<U>(transformer: (value: T) => U): U;
+    addValidator(validator: (value: T) => boolean): this;
+    onError(handler: (error: Error) => void): this;
+}
+
+/**
+ * @solana/connector - Browser Compatibility Polyfills
+ *
+ * Ensures connector works across all browser environments including:
+ * - Mobile browsers (iOS Safari, Chrome Mobile, etc.)
+ * - Older desktop browsers
+ * - Environments with restricted crypto APIs
+ *
+ * Inspired by wallet-adapter-compat's polyfill strategy
+ */
+/**
+ * Install browser compatibility polyfills
+ *
+ * This function:
+ * - Installs WebCrypto Ed25519 polyfill for signature operations
+ * - Is safe to call multiple times (idempotent)
+ * - Only runs in browser environments
+ * - Fails gracefully if installation errors occur
+ *
+ * @example
+ * ```ts
+ * // Automatically called when connector-provider is imported
+ * import { ConnectorProvider } from '@solana/connector'
+ *
+ * // Can also be called manually if needed
+ * import { installPolyfills } from '@solana/connector/headless'
+ * installPolyfills()
+ * ```
+ */
+declare function installPolyfills(): void;
+/**
+ * Check if polyfills have been installed
+ * Useful for debugging and health checks
+ *
+ * @returns True if polyfills are installed, false otherwise
+ *
+ * @example
+ * ```ts
+ * import { isPolyfillInstalled } from '@solana/connector/headless'
+ *
+ * if (!isPolyfillInstalled()) {
+ *   console.warn('Polyfills not installed - may have issues on older browsers')
+ * }
+ * ```
+ */
+declare function isPolyfillInstalled(): boolean;
+/**
+ * Check if WebCrypto API is available
+ * Useful for detecting environments with restricted crypto capabilities
+ *
+ * @returns True if crypto.subtle is available, false otherwise
+ *
+ * @example
+ * ```ts
+ * import { isCryptoAvailable } from '@solana/connector/headless'
+ *
+ * if (!isCryptoAvailable()) {
+ *   // Show warning to user about unsupported browser
+ * }
+ * ```
+ */
+declare function isCryptoAvailable(): boolean;
+/**
+ * Get polyfill status information
+ * Returns detailed information about polyfill and crypto availability
+ *
+ * @returns Object with polyfill status details
+ *
+ * @example
+ * ```ts
+ * import { getPolyfillStatus } from '@solana/connector/headless'
+ *
+ * const status = getPolyfillStatus()
+ * console.log('Polyfills:', status.installed ? 'installed' : 'not installed')
+ * console.log('WebCrypto:', status.cryptoAvailable ? 'available' : 'unavailable')
+ * ```
+ */
+declare function getPolyfillStatus(): {
+    installed: boolean;
+    cryptoAvailable: boolean;
+    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';
+type KitRpc = {
+    getLatestBlockhash(options?: {
+        commitment?: Commitment;
+    }): {
+        send(): Promise<{
+            value: {
+                blockhash: string;
+                lastValidBlockHeight: number;
+            };
+        }>;
+    };
+    sendTransaction(bytes: Uint8Array | string, options?: any): {
+        send(): Promise<string>;
+    };
+    send?: () => unknown;
+};
+type DualConnection = Connection | KitRpc;
+declare function isLegacyConnection(conn: DualConnection): conn is Connection;
+declare function isKitConnection(conn: DualConnection): conn is KitRpc;
+
+/**
+ * @solana/connector - Connection Helpers
+ *
+ * Abstraction layer for working with both legacy @solana/web3.js Connection
+ * and modern Kit/gill Rpc objects.
+ */
+
+/**
+ * Get latest blockhash from either legacy Connection or Kit Rpc
+ *
+ * Abstracts the differences between web3.js 1.x and Kit/gill APIs.
+ *
+ * @param connection - Legacy Connection or Kit Rpc
+ * @param commitment - Optional commitment level (default: 'confirmed')
+ * @returns Latest blockhash and last valid block height
+ *
+ * @example
+ * ```typescript
+ * // Works with both Connection and Rpc
+ * const { blockhash, lastValidBlockHeight } = await getLatestBlockhash(connection);
+ * ```
+ */
+declare function getLatestBlockhash(connection: DualConnection, commitment?: Commitment): Promise<{
+    blockhash: string;
+    lastValidBlockHeight: number;
+}>;
+/**
+ * Send raw transaction bytes to either legacy Connection or Kit Rpc
+ *
+ * Abstracts the differences between web3.js 1.x and Kit/gill APIs.
+ *
+ * @param connection - Legacy Connection or Kit Rpc
+ * @param bytes - Raw transaction bytes
+ * @param options - Optional send options (skipPreflight, maxRetries, etc.)
+ * @returns Transaction signature string
+ *
+ * @example
+ * ```typescript
+ * // Works with both Connection and Rpc
+ * const signature = await sendRawTransaction(connection, transactionBytes, {
+ *   skipPreflight: false,
+ *   maxRetries: 3
+ * });
+ * ```
+ */
+declare function sendRawTransaction(connection: DualConnection, bytes: Uint8Array, options?: SendOptions & {
+    commitment?: Commitment;
+}): Promise<string>;
+
+/**
+ * @solana/connector - Explorer URL Utilities
+ *
+ * Generate URLs for various Solana block explorers to view transactions,
+ * accounts, and other on-chain data.
+ */
+type ExplorerType = 'solana-explorer' | 'solscan' | 'xray' | 'solana-fm';
+interface ExplorerOptions {
+    /** Cluster to use for the explorer link */
+    cluster?: string;
+    /** Custom RPC URL for localnet */
+    customUrl?: string;
+}
+/**
+ * Generate Solana Explorer URL for a transaction signature
+ */
+declare function getSolanaExplorerUrl(signature: string, options?: ExplorerOptions): string;
+/**
+ * Generate Solscan URL for a transaction signature
+ */
+declare function getSolscanUrl(signature: string, options?: ExplorerOptions): string;
+/**
+ * Generate XRAY (Helius) URL for a transaction signature
+ * Note: XRAY works best with mainnet transactions
+ */
+declare function getXrayUrl(signature: string): string;
+/**
+ * Generate SolanaFM URL for a transaction signature
+ */
+declare function getSolanaFmUrl(signature: string, options?: ExplorerOptions): string;
+/**
+ * Get all explorer URLs for a transaction
+ */
+declare function getAllExplorerUrls(signature: string, options?: ExplorerOptions): Record<ExplorerType, string>;
+/**
+ * Format a transaction signature for display (truncated)
+ */
+declare function formatSignature(signature: string, chars?: number): string;
+/**
+ * Copy signature to clipboard with enhanced error handling
+ *
+ * @deprecated Use copySignatureToClipboard from utils/clipboard instead
+ * This is maintained for backwards compatibility but will be removed in a future version
+ */
+declare function copySignature(signature: string): Promise<boolean>;
+
+export { ClusterType, type Commitment, type DualConnection, EnhancedStorage, EnhancedStorageAccountOptions, EnhancedStorageAdapter, EnhancedStorageClusterOptions, EnhancedStorageWalletOptions, type ExplorerOptions, type ExplorerType, type KitSignersFromWallet, SOLANA_CHAIN_IDS, StorageAdapter, StorageOptions, TransactionSigner, base58ToSignatureBytes, chainIdToClusterId, chainIdToClusterType, clusterToChainId, copySignature, createEnhancedStorageAccount, createEnhancedStorageCluster, createEnhancedStorageWallet, createGillTransactionSigner, createKitSignersFromWallet, createMessageSignerFromWallet, createTransactionSendingSignerFromWallet, detectMessageModification, formatAddress, formatNumber, formatSOL, formatSignature, formatTokenAmount, freezeSigner, getAllExplorerUrls, getChainIdFromCluster, getChainIdFromClusterId, getChainIdFromClusterType, getChainIdFromConnection, getClusterIdFromChainId, getClusterTypeFromChainId, getClusterTypeFromConnection, getLatestBlockhash, getPolyfillStatus, getSolanaExplorerUrl, getSolanaFmUrl, getSolscanUrl, getXrayUrl, installPolyfills, isCryptoAvailable, isKitConnection, isKnownSolanaChain, isLegacyConnection, isPolyfillInstalled, isSolanaChain, sendRawTransaction, signatureBytesToBase58, truncate, updateSignatureDictionary, validateKnownSolanaChain };