@formo/analytics 1.26.0 → 1.28.0

package/dist/cjs/src/solana/SolanaManager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SolanaManager
+ *
+ * Manages the lifecycle of the SolanaAdapter, handling lazy initialization
+ * and pending configuration. This keeps Solana-specific lifecycle logic out of
+ * the main FormoAnalytics class.
+ */
+import { FormoAnalytics } from "../FormoAnalytics";
+import { SolanaAdapter } from "./SolanaAdapter";
+import { ISolanaAdapter, SolanaWalletContext, SolanaConnection, SolanaCluster, SolanaOptions } from "./types";
+export declare class SolanaManager {
+    private formo;
+    private handler?;
+    private pendingConnection?;
+    private pendingCluster?;
+    constructor(formo: FormoAnalytics, options?: SolanaOptions);
+    get adapter(): SolanaAdapter | undefined;
+    setWallet(wallet: ISolanaAdapter | SolanaWalletContext | null): void;
+    setConnection(connection: SolanaConnection | null): void;
+    setCluster(cluster: SolanaCluster): void;
+    syncWalletState(): void;
+    cleanup(): void;
+}
+//# sourceMappingURL=SolanaManager.d.ts.map

package/dist/cjs/src/solana/SolanaManager.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * SolanaManager
+ *
+ * Manages the lifecycle of the SolanaAdapter, handling lazy initialization
+ * and pending configuration. This keeps Solana-specific lifecycle logic out of
+ * the main FormoAnalytics class.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaManager = void 0;
+var logger_1 = require("../logger");
+var SolanaAdapter_1 = require("./SolanaAdapter");
+var SolanaManager = /** @class */ (function () {
+    function SolanaManager(formo, options) {
+        this.formo = formo;
+        if (options === null || options === void 0 ? void 0 : options.wallet) {
+            logger_1.logger.info("SolanaManager: Initializing Solana wallet tracking");
+            this.handler = new SolanaAdapter_1.SolanaAdapter(formo, {
+                wallet: options.wallet,
+                connection: options.connection,
+                cluster: options.cluster,
+            });
+        }
+        else if (options) {
+            // Store pending values for when wallet is set later
+            this.pendingConnection = options.connection;
+            this.pendingCluster = options.cluster;
+        }
+    }
+    Object.defineProperty(SolanaManager.prototype, "adapter", {
+        get: function () {
+            return this.handler;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SolanaManager.prototype.setWallet = function (wallet) {
+        if (this.handler) {
+            this.handler.setWallet(wallet);
+        }
+        else if (wallet) {
+            logger_1.logger.info("SolanaManager: Initializing Solana wallet tracking (lazy)");
+            this.handler = new SolanaAdapter_1.SolanaAdapter(this.formo, {
+                wallet: wallet,
+                connection: this.pendingConnection,
+                cluster: this.pendingCluster,
+            });
+            this.pendingConnection = undefined;
+            this.pendingCluster = undefined;
+        }
+    };
+    SolanaManager.prototype.setConnection = function (connection) {
+        if (this.handler) {
+            this.handler.setConnection(connection);
+        }
+        else {
+            this.pendingConnection = connection !== null && connection !== void 0 ? connection : undefined;
+        }
+    };
+    SolanaManager.prototype.setCluster = function (cluster) {
+        if (this.handler) {
+            this.handler.setCluster(cluster);
+        }
+        else {
+            this.pendingCluster = cluster;
+        }
+    };
+    SolanaManager.prototype.syncWalletState = function () {
+        var _a;
+        (_a = this.handler) === null || _a === void 0 ? void 0 : _a.syncWalletState();
+    };
+    SolanaManager.prototype.cleanup = function () {
+        var _a;
+        (_a = this.handler) === null || _a === void 0 ? void 0 : _a.cleanup();
+        this.handler = undefined;
+    };
+    return SolanaManager;
+}());
+exports.SolanaManager = SolanaManager;
+//# sourceMappingURL=SolanaManager.js.map

package/dist/cjs/src/solana/address.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Solana address validation utilities
+ *
+ * Solana uses Base58 encoded 32-byte public keys as addresses.
+ * Format: FDKJvWcJNe6wecbgDYDFPCfgs14aJnVsUfWQRYWLn4Tn (32-44 characters)
+ *
+ * @see https://solana.com/developers/courses/intro-to-solana/interact-with-wallets
+ */
+import { SolanaPublicKey } from "./types";
+/**
+ * System program addresses and other special Solana addresses
+ * These are valid addresses but may not represent user wallets
+ */
+export declare const SOLANA_SYSTEM_ADDRESSES: {
+    readonly SYSTEM_PROGRAM: "11111111111111111111111111111111";
+    readonly TOKEN_PROGRAM: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+    readonly TOKEN_2022_PROGRAM: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+    readonly ASSOCIATED_TOKEN_PROGRAM: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+    readonly RENT_SYSVAR: "SysvarRent111111111111111111111111111111111";
+    readonly CLOCK_SYSVAR: "SysvarC1ock11111111111111111111111111111111";
+};
+/**
+ * Check if a string is a valid Solana address format
+ *
+ * This performs format validation only (length and character set).
+ * It does NOT validate that the address is a valid point on the Ed25519 curve.
+ *
+ * @param value The value to check
+ * @returns true if the value is a valid Solana address format
+ */
+export declare function isSolanaAddress(value: unknown): value is string;
+/**
+ * Get a valid Solana address from a string or PublicKey
+ *
+ * @param address The address to validate (string or PublicKey)
+ * @returns The address string if valid, null otherwise
+ */
+export declare function getValidSolanaAddress(address: string | SolanaPublicKey | null | undefined): string | null;
+/**
+ * Check if a Solana address is a system program or well-known program address
+ *
+ * @param address The address to check
+ * @returns true if the address is a system/program address
+ */
+export declare function isSolanaSystemAddress(address: string): boolean;
+/**
+ * Check if a Solana address is blocked (should not emit events)
+ *
+ * For Solana, we block system program addresses as they don't represent user wallets.
+ *
+ * @param address The address to check
+ * @returns true if the address should be blocked
+ */
+export declare function isBlockedSolanaAddress(address: string | SolanaPublicKey | null | undefined): boolean;
+/**
+ * Convert a Solana PublicKey to a string address
+ *
+ * @param publicKey The public key to convert
+ * @returns The Base58 encoded address string, or null if invalid
+ */
+export declare function publicKeyToAddress(publicKey: SolanaPublicKey | null | undefined): string | null;
+/**
+ * Check if two Solana addresses are equal (case-sensitive comparison)
+ *
+ * Unlike EVM addresses, Solana addresses are case-sensitive Base58.
+ *
+ * @param address1 First address
+ * @param address2 Second address
+ * @returns true if addresses are equal
+ */
+export declare function areSolanaAddressesEqual(address1: string | SolanaPublicKey | null | undefined, address2: string | SolanaPublicKey | null | undefined): boolean;
+//# sourceMappingURL=address.d.ts.map

package/dist/cjs/src/solana/address.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Solana address validation utilities
+ *
+ * Solana uses Base58 encoded 32-byte public keys as addresses.
+ * Format: FDKJvWcJNe6wecbgDYDFPCfgs14aJnVsUfWQRYWLn4Tn (32-44 characters)
+ *
+ * @see https://solana.com/developers/courses/intro-to-solana/interact-with-wallets
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_SYSTEM_ADDRESSES = void 0;
+exports.isSolanaAddress = isSolanaAddress;
+exports.getValidSolanaAddress = getValidSolanaAddress;
+exports.isSolanaSystemAddress = isSolanaSystemAddress;
+exports.isBlockedSolanaAddress = isBlockedSolanaAddress;
+exports.publicKeyToAddress = publicKeyToAddress;
+exports.areSolanaAddressesEqual = areSolanaAddressesEqual;
+/**
+ * Base58 alphabet used by Solana (Bitcoin alphabet)
+ */
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+ * Set for O(1) lookup of valid Base58 characters
+ */
+var BASE58_CHAR_SET = new Set(BASE58_ALPHABET);
+/**
+ * Minimum length of a Solana address (Base58 encoded)
+ * A 32-byte key will be at least 32 characters when Base58 encoded
+ */
+var MIN_SOLANA_ADDRESS_LENGTH = 32;
+/**
+ * Maximum length of a Solana address (Base58 encoded)
+ * A 32-byte key will be at most 44 characters when Base58 encoded
+ */
+var MAX_SOLANA_ADDRESS_LENGTH = 44;
+/**
+ * System program addresses and other special Solana addresses
+ * These are valid addresses but may not represent user wallets
+ */
+exports.SOLANA_SYSTEM_ADDRESSES = {
+    SYSTEM_PROGRAM: "11111111111111111111111111111111",
+    TOKEN_PROGRAM: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+    TOKEN_2022_PROGRAM: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb",
+    ASSOCIATED_TOKEN_PROGRAM: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+    RENT_SYSVAR: "SysvarRent111111111111111111111111111111111",
+    CLOCK_SYSVAR: "SysvarC1ock11111111111111111111111111111111",
+};
+/**
+ * Check if a string contains only valid Base58 characters
+ */
+function isValidBase58String(str) {
+    for (var i = 0; i < str.length; i++) {
+        if (!BASE58_CHAR_SET.has(str[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if a string is a valid Solana address format
+ *
+ * This performs format validation only (length and character set).
+ * It does NOT validate that the address is a valid point on the Ed25519 curve.
+ *
+ * @param value The value to check
+ * @returns true if the value is a valid Solana address format
+ */
+function isSolanaAddress(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    var trimmed = value.trim();
+    // Check length bounds
+    if (trimmed.length < MIN_SOLANA_ADDRESS_LENGTH ||
+        trimmed.length > MAX_SOLANA_ADDRESS_LENGTH) {
+        return false;
+    }
+    // Check character set (Base58)
+    return isValidBase58String(trimmed);
+}
+/**
+ * Get a valid Solana address from a string or PublicKey
+ *
+ * @param address The address to validate (string or PublicKey)
+ * @returns The address string if valid, null otherwise
+ */
+function getValidSolanaAddress(address) {
+    if (!address) {
+        return null;
+    }
+    // Handle PublicKey objects
+    if (typeof address === "object" && "toBase58" in address) {
+        try {
+            var base58 = address.toBase58();
+            return isSolanaAddress(base58) ? base58 : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // Handle strings
+    if (typeof address === "string") {
+        var trimmed = address.trim();
+        return isSolanaAddress(trimmed) ? trimmed : null;
+    }
+    return null;
+}
+/**
+ * Check if a Solana address is a system program or well-known program address
+ *
+ * @param address The address to check
+ * @returns true if the address is a system/program address
+ */
+function isSolanaSystemAddress(address) {
+    var validAddress = getValidSolanaAddress(address);
+    if (!validAddress) {
+        return false;
+    }
+    return Object.values(exports.SOLANA_SYSTEM_ADDRESSES).includes(validAddress);
+}
+/**
+ * Check if a Solana address is blocked (should not emit events)
+ *
+ * For Solana, we block system program addresses as they don't represent user wallets.
+ *
+ * @param address The address to check
+ * @returns true if the address should be blocked
+ */
+function isBlockedSolanaAddress(address) {
+    var validAddress = getValidSolanaAddress(address);
+    if (!validAddress) {
+        return false;
+    }
+    // Block system addresses (includes SYSTEM_PROGRAM, TOKEN_PROGRAM, etc.)
+    if (isSolanaSystemAddress(validAddress)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Convert a Solana PublicKey to a string address
+ *
+ * @param publicKey The public key to convert
+ * @returns The Base58 encoded address string, or null if invalid
+ */
+function publicKeyToAddress(publicKey) {
+    if (!publicKey) {
+        return null;
+    }
+    try {
+        var address = publicKey.toBase58();
+        return isSolanaAddress(address) ? address : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Check if two Solana addresses are equal (case-sensitive comparison)
+ *
+ * Unlike EVM addresses, Solana addresses are case-sensitive Base58.
+ *
+ * @param address1 First address
+ * @param address2 Second address
+ * @returns true if addresses are equal
+ */
+function areSolanaAddressesEqual(address1, address2) {
+    var addr1 = getValidSolanaAddress(address1);
+    var addr2 = getValidSolanaAddress(address2);
+    if (!addr1 || !addr2) {
+        return false;
+    }
+    // Solana addresses are case-sensitive
+    return addr1 === addr2;
+}
+//# sourceMappingURL=address.js.map

package/dist/cjs/src/solana/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Solana integration module
+ *
+ * Provides integration with Solana Wallet Adapter for wallet event tracking.
+ * This module exports the SolanaAdapter and related types.
+ *
+ * @see https://github.com/anza-xyz/wallet-adapter
+ */
+export { SolanaAdapter } from "./SolanaAdapter";
+export { SolanaManager } from "./SolanaManager";
+export * from "./types";
+export * from "./address";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/solana/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Solana integration module
+ *
+ * Provides integration with Solana Wallet Adapter for wallet event tracking.
+ * This module exports the SolanaAdapter and related types.
+ *
+ * @see https://github.com/anza-xyz/wallet-adapter
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaManager = exports.SolanaAdapter = void 0;
+var SolanaAdapter_1 = require("./SolanaAdapter");
+Object.defineProperty(exports, "SolanaAdapter", { enumerable: true, get: function () { return SolanaAdapter_1.SolanaAdapter; } });
+var SolanaManager_1 = require("./SolanaManager");
+Object.defineProperty(exports, "SolanaManager", { enumerable: true, get: function () { return SolanaManager_1.SolanaManager; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./address"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/solana/types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Solana-specific type definitions for wallet event tracking
+ *
+ * These types provide TypeScript interfaces for Solana Wallet Adapter integration,
+ * allowing the SDK to hook into Solana wallet events to track wallet interactions.
+ *
+ * @see https://github.com/anza-xyz/wallet-adapter
+ */
+/**
+ * Solana cluster/network types
+ * Solana doesn't use chainId like EVM, instead it uses cluster names
+ */
+export type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
+/**
+ * Mapping of Solana clusters to numeric chain IDs for consistency with EVM events
+ * These IDs are non-standard but provide a way to identify Solana networks in our analytics
+ *
+ * Using high numbers (900000+) to avoid collision with EVM chain IDs
+ * @see https://chainlist.org for EVM chain IDs (typically < 100000)
+ */
+export declare const SOLANA_CHAIN_IDS: Record<SolanaCluster, number>;
+/**
+ * Reverse mapping from chain ID to cluster name
+ */
+export declare const SOLANA_CLUSTERS_BY_ID: Record<number, SolanaCluster>;
+/**
+ * Default Solana chain ID (mainnet-beta)
+ */
+export declare const DEFAULT_SOLANA_CHAIN_ID: number;
+/**
+ * Check if a chain ID belongs to a Solana network.
+ */
+export declare function isSolanaChainId(chainId: number | undefined | null): boolean;
+/**
+ * Solana PublicKey interface
+ * Represents a Solana public key (32 bytes, Base58 encoded)
+ */
+export interface SolanaPublicKey {
+    toBase58(): string;
+    toString(): string;
+    toBytes(): Uint8Array;
+    equals(other: SolanaPublicKey): boolean;
+}
+/**
+ * Solana transaction signature (64 bytes, Base58 encoded)
+ */
+export type TransactionSignature = string;
+/**
+ * Solana wallet adapter state
+ */
+export type WalletAdapterState = "connected" | "disconnected" | "connecting" | "disconnecting";
+/**
+ * Solana wallet adapter interface
+ * Based on @solana/wallet-adapter-base WalletAdapter
+ */
+export interface ISolanaAdapter {
+    name: string;
+    url: string;
+    icon: string;
+    readyState: WalletReadyState;
+    publicKey: SolanaPublicKey | null;
+    connecting: boolean;
+    connected: boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendTransaction?(transaction: SolanaTransaction, connection: SolanaConnection, options?: SendTransactionOptions): Promise<TransactionSignature>;
+    signTransaction?(transaction: SolanaTransaction): Promise<SolanaTransaction>;
+    signAllTransactions?(transactions: SolanaTransaction[]): Promise<SolanaTransaction[]>;
+    signMessage?(message: Uint8Array): Promise<Uint8Array>;
+    on(event: "connect", listener: (publicKey: SolanaPublicKey) => void): void;
+    on(event: "disconnect", listener: () => void): void;
+    on(event: "error", listener: (error: WalletError) => void): void;
+    on(event: "readyStateChange", listener: (readyState: WalletReadyState) => void): void;
+    off(event: string, listener: (...args: unknown[]) => void): void;
+    removeAllListeners?(event?: string): void;
+}
+/**
+ * Solana wallet ready state
+ */
+export declare enum WalletReadyState {
+    Installed = "Installed",
+    NotDetected = "NotDetected",
+    Loadable = "Loadable",
+    Unsupported = "Unsupported"
+}
+/**
+ * Solana wallet error
+ */
+export interface WalletError extends Error {
+    error?: unknown;
+}
+/**
+ * Solana transaction interface (minimal)
+ */
+export interface SolanaTransaction {
+    signature?: Uint8Array;
+    serialize(): Uint8Array;
+    feePayer?: SolanaPublicKey;
+    recentBlockhash?: string;
+}
+/**
+ * Solana connection interface (minimal)
+ */
+export interface SolanaConnection {
+    rpcEndpoint: string;
+    commitment?: string;
+    getSignatureStatus?(signature: string): Promise<{
+        value: SignatureStatus | null;
+    }>;
+    getSignatureStatuses?(signatures: string[]): Promise<{
+        value: (SignatureStatus | null)[];
+    }>;
+}
+/**
+ * Solana signature status
+ */
+export interface SignatureStatus {
+    slot: number;
+    confirmations: number | null;
+    err: unknown | null;
+    confirmationStatus?: "processed" | "confirmed" | "finalized";
+}
+/**
+ * Send transaction options
+ */
+export interface SendTransactionOptions {
+    skipPreflight?: boolean;
+    preflightCommitment?: string;
+    maxRetries?: number;
+    minContextSlot?: number;
+}
+/**
+ * Wallet entry as returned by @solana/wallet-adapter-react useWallet().wallet
+ * This is { adapter, readyState }, not a direct adapter.
+ */
+export interface SolanaWalletEntry {
+    adapter: ISolanaAdapter;
+    readyState: WalletReadyState;
+}
+/**
+ * @deprecated Use SolanaWalletEntry instead
+ */
+export type SolanaWallet = SolanaWalletEntry;
+/**
+ * Solana Wallet Context interface
+ * Based on @solana/wallet-adapter-react useWallet hook
+ * @see https://github.com/anza-xyz/wallet-adapter/blob/master/packages/core/react/src/useWallet.ts
+ */
+export interface SolanaWalletContext {
+    autoConnect: boolean;
+    wallets: SolanaWalletEntry[];
+    wallet: SolanaWalletEntry | null;
+    publicKey: SolanaPublicKey | null;
+    connecting: boolean;
+    connected: boolean;
+    disconnecting: boolean;
+    select(walletName: string | null): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendTransaction(transaction: SolanaTransaction, connection: SolanaConnection, options?: SendTransactionOptions): Promise<TransactionSignature>;
+    signTransaction?(transaction: SolanaTransaction): Promise<SolanaTransaction>;
+    signAllTransactions?(transactions: SolanaTransaction[]): Promise<SolanaTransaction[]>;
+    signMessage?(message: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Solana options for FormoAnalytics
+ */
+export interface SolanaOptions {
+    /**
+     * The Solana wallet adapter instance or wallet context
+     * Can be a single wallet adapter or the useWallet() context
+     */
+    wallet?: ISolanaAdapter | SolanaWalletContext;
+    /**
+     * The Solana connection for tracking transaction confirmations
+     */
+    connection?: SolanaConnection;
+    /**
+     * The Solana cluster/network
+     * @default "mainnet-beta"
+     */
+    cluster?: SolanaCluster;
+}
+/**
+ * Internal connection state for Solana event handler.
+ * Tracks the last known wallet connection for disconnect event payloads
+ * and provides a reentrancy guard for concurrent event handling.
+ */
+export interface SolanaConnectionState {
+    lastAddress?: string;
+    lastChainId?: number;
+    isProcessing: boolean;
+}
+/**
+ * Unsubscribe function type
+ */
+export type UnsubscribeFn = () => void;
+/**
+ * Check if an object is a SolanaWalletContext (has wallets array)
+ */
+export declare function isSolanaWalletContext(obj: ISolanaAdapter | SolanaWalletContext | undefined | null): obj is SolanaWalletContext;
+/**
+ * Check if an object is a ISolanaAdapter
+ */
+export declare function isSolanaAdapter(obj: ISolanaAdapter | SolanaWalletContext | undefined | null): obj is ISolanaAdapter;
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/src/solana/types.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Solana-specific type definitions for wallet event tracking
+ *
+ * These types provide TypeScript interfaces for Solana Wallet Adapter integration,
+ * allowing the SDK to hook into Solana wallet events to track wallet interactions.
+ *
+ * @see https://github.com/anza-xyz/wallet-adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletReadyState = exports.DEFAULT_SOLANA_CHAIN_ID = exports.SOLANA_CLUSTERS_BY_ID = exports.SOLANA_CHAIN_IDS = void 0;
+exports.isSolanaChainId = isSolanaChainId;
+exports.isSolanaWalletContext = isSolanaWalletContext;
+exports.isSolanaAdapter = isSolanaAdapter;
+/**
+ * Mapping of Solana clusters to numeric chain IDs for consistency with EVM events
+ * These IDs are non-standard but provide a way to identify Solana networks in our analytics
+ *
+ * Using high numbers (900000+) to avoid collision with EVM chain IDs
+ * @see https://chainlist.org for EVM chain IDs (typically < 100000)
+ */
+exports.SOLANA_CHAIN_IDS = {
+    "mainnet-beta": 900001,
+    testnet: 900002,
+    devnet: 900003,
+    localnet: 900004,
+};
+/**
+ * Reverse mapping from chain ID to cluster name
+ */
+exports.SOLANA_CLUSTERS_BY_ID = {
+    900001: "mainnet-beta",
+    900002: "testnet",
+    900003: "devnet",
+    900004: "localnet",
+};
+/**
+ * Default Solana chain ID (mainnet-beta)
+ */
+exports.DEFAULT_SOLANA_CHAIN_ID = exports.SOLANA_CHAIN_IDS["mainnet-beta"];
+/**
+ * Check if a chain ID belongs to a Solana network.
+ */
+function isSolanaChainId(chainId) {
+    if (chainId === undefined || chainId === null)
+        return false;
+    return Object.values(exports.SOLANA_CHAIN_IDS).includes(chainId);
+}
+/**
+ * Solana wallet ready state
+ */
+var WalletReadyState;
+(function (WalletReadyState) {
+    WalletReadyState["Installed"] = "Installed";
+    WalletReadyState["NotDetected"] = "NotDetected";
+    WalletReadyState["Loadable"] = "Loadable";
+    WalletReadyState["Unsupported"] = "Unsupported";
+})(WalletReadyState || (exports.WalletReadyState = WalletReadyState = {}));
+/**
+ * Check if an object is a SolanaWalletContext (has wallets array)
+ */
+function isSolanaWalletContext(obj) {
+    return (obj !== null &&
+        obj !== undefined &&
+        typeof obj === "object" &&
+        "wallets" in obj &&
+        Array.isArray(obj.wallets));
+}
+/**
+ * Check if an object is a ISolanaAdapter
+ */
+function isSolanaAdapter(obj) {
+    return (obj !== null &&
+        obj !== undefined &&
+        typeof obj === "object" &&
+        "name" in obj &&
+        "connect" in obj &&
+        !("wallets" in obj));
+}
+//# sourceMappingURL=types.js.map