@formo/analytics 1.28.5 → 1.28.6

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

@@ -0,0 +1,471 @@
+"use strict";
+/**
+ * SolanaStoreHandler
+ *
+ * Handles wallet event tracking by subscribing to framework-kit's zustand store.
+ * This provides automatic event capture (autocapture) for Solana wallets without
+ * wrapping any wallet methods — similar to how WagmiEventHandler subscribes to
+ * TanStack Query's mutation/query caches.
+ *
+ * Subscribes to:
+ * - `state.wallet` — connect/disconnect events
+ * - `state.transactions` — transaction lifecycle events (sending → confirmed/failed)
+ *
+ * @see https://github.com/solana-foundation/framework-kit
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaStoreHandler = void 0;
+var events_1 = require("../types/events");
+var logger_1 = require("../logger");
+var types_1 = require("./types");
+var address_1 = require("./address");
+/**
+ * Clean up old entries from a Set to prevent memory leaks.
+ */
+function cleanupOldEntries(set, maxSize, removeCount) {
+    if (maxSize === void 0) { maxSize = 1000; }
+    if (removeCount === void 0) { removeCount = 500; }
+    if (set.size > maxSize) {
+        var entries = Array.from(set);
+        for (var i = 0; i < removeCount && i < entries.length; i++) {
+            set.delete(entries[i]);
+        }
+    }
+}
+var SolanaStoreHandler = /** @class */ (function () {
+    function SolanaStoreHandler(formoAnalytics, store, options) {
+        this.unsubscribers = [];
+        /**
+         * Track last known wallet status to detect transitions.
+         */
+        this.lastWalletStatus = "disconnected";
+        /**
+         * Track processed transaction state changes to prevent duplicate events.
+         * Key format: `${signature}:${status}`
+         */
+        this.processedTransactions = new Set();
+        /**
+         * Track transactions we've emitted STARTED for (status was "sending").
+         * Ensures we only emit STARTED once per transaction key.
+         */
+        this.startedTransactions = new Set();
+        /**
+         * Per-transaction sender address captured at STARTED time.
+         * Ensures terminal events (confirmed/failed) are attributed correctly
+         * even if the wallet disconnects before the transaction settles.
+         */
+        this.transactionSenders = new Map();
+        this.formo = formoAnalytics;
+        this.store = store;
+        this.explicitCluster = !!(options === null || options === void 0 ? void 0 : options.cluster);
+        this.cluster = (options === null || options === void 0 ? void 0 : options.cluster) || this.detectClusterFromStore(store) || "mainnet-beta";
+        this.chainId = types_1.SOLANA_CHAIN_IDS[this.cluster];
+        logger_1.logger.info("SolanaStoreHandler: Initializing framework-kit store integration", {
+            cluster: this.cluster,
+            chainId: this.chainId,
+        });
+        this.setupWalletSubscription();
+        this.setupTransactionSubscription();
+        this.setupClusterSubscription();
+        // Check initial wallet state
+        this.checkInitialWalletState();
+    }
+    /**
+     * Update the cluster/network.
+     */
+    SolanaStoreHandler.prototype.setCluster = function (cluster) {
+        this.explicitCluster = true;
+        var previousCluster = this.cluster;
+        this.cluster = cluster;
+        this.chainId = types_1.SOLANA_CHAIN_IDS[cluster];
+        if (previousCluster !== cluster && this.lastAddress) {
+            this.lastChainId = this.chainId;
+            if (this.formo.isAutocaptureEnabled("chain")) {
+                this.formo.chain({
+                    chainId: this.chainId,
+                    address: this.lastAddress,
+                }).catch(function (error) {
+                    logger_1.logger.error("SolanaStoreHandler: Error emitting chain event", error);
+                });
+            }
+        }
+    };
+    /**
+     * Get the current chain ID.
+     */
+    SolanaStoreHandler.prototype.getChainId = function () {
+        return this.chainId;
+    };
+    /**
+     * Resolve the current chainId from the live store state.
+     * This ensures correctness when wallet and cluster change in the same tick
+     * (the cluster subscription may not have fired yet).
+     */
+    SolanaStoreHandler.prototype.resolveCurrentChainId = function () {
+        // Don't auto-detect if the cluster was explicitly set
+        if (!this.explicitCluster) {
+            var detected = this.detectClusterFromStore(this.store);
+            if (detected) {
+                this.cluster = detected;
+                this.chainId = types_1.SOLANA_CHAIN_IDS[detected];
+            }
+        }
+        return this.chainId;
+    };
+    // ============================================================
+    // Wallet Subscription
+    // ============================================================
+    SolanaStoreHandler.prototype.setupWalletSubscription = function () {
+        var _this = this;
+        var prevWallet = this.store.getState().wallet;
+        var unsubscribe = this.store.subscribe(function (state) {
+            var wallet = state.wallet;
+            if (wallet !== prevWallet) {
+                var prev = prevWallet;
+                prevWallet = wallet;
+                _this.handleWalletChange(wallet, prev);
+            }
+        });
+        this.unsubscribers.push(unsubscribe);
+        logger_1.logger.info("SolanaStoreHandler: Wallet subscription set up");
+    };
+    SolanaStoreHandler.prototype.checkInitialWalletState = function () {
+        var _a;
+        var state = this.store.getState();
+        var wallet = state.wallet;
+        if (wallet.status === "connected") {
+            var address = wallet.session.account.address;
+            if (address && !(0, address_1.isBlockedSolanaAddress)(address)) {
+                this.lastWalletStatus = "connected";
+                this.lastAddress = address;
+                this.lastChainId = this.chainId;
+                logger_1.logger.info("SolanaStoreHandler: Already connected on initialization", {
+                    address: address,
+                    chainId: this.chainId,
+                });
+                if (this.formo.isAutocaptureEnabled("connect")) {
+                    var connectorName = ((_a = wallet.session.connector) === null || _a === void 0 ? void 0 : _a.name) || wallet.connectorId;
+                    this.formo.connect({ chainId: this.chainId, address: address }, {
+                        providerName: connectorName,
+                        rdns: "sol.wallet.".concat(connectorName.toLowerCase().replace(/\s+/g, "")),
+                    }).catch(function (error) {
+                        logger_1.logger.error("SolanaStoreHandler: Error emitting initial connect", error);
+                    });
+                }
+            }
+        }
+        this.lastWalletStatus = wallet.status;
+    };
+    SolanaStoreHandler.prototype.handleWalletChange = function (wallet, prevWallet) {
+        // connected → any other state (disconnected, error, connecting)
+        if (prevWallet.status === "connected" &&
+            wallet.status !== "connected") {
+            this.handleDisconnect();
+        }
+        // * → connected (new connection)
+        if (wallet.status === "connected" && prevWallet.status !== "connected") {
+            this.handleConnect(wallet);
+        }
+        else if (wallet.status === "connected" &&
+            prevWallet.status === "connected") {
+            // connected → connected: check for account switch OR connector change
+            var addressChanged = wallet.session.account.address !== prevWallet.session.account.address;
+            var connectorChanged = wallet.connectorId !== prevWallet.connectorId;
+            if (addressChanged || connectorChanged) {
+                this.handleDisconnect();
+                this.handleConnect(wallet);
+            }
+        }
+        this.lastWalletStatus = wallet.status;
+    };
+    SolanaStoreHandler.prototype.handleConnect = function (wallet) {
+        var _a;
+        var address = wallet.session.account.address;
+        if (!address || (0, address_1.isBlockedSolanaAddress)(address)) {
+            return;
+        }
+        // Resolve chainId from live store state so batched wallet+cluster
+        // updates use the correct network even if the cluster subscription
+        // hasn't fired yet.
+        var chainId = this.resolveCurrentChainId();
+        this.lastAddress = address;
+        this.lastChainId = chainId;
+        logger_1.logger.info("SolanaStoreHandler: Wallet connected", {
+            address: address,
+            chainId: chainId,
+            connector: wallet.connectorId,
+        });
+        if (this.formo.isAutocaptureEnabled("connect")) {
+            var connectorName = ((_a = wallet.session.connector) === null || _a === void 0 ? void 0 : _a.name) || wallet.connectorId;
+            this.formo.connect({ chainId: chainId, address: address }, {
+                providerName: connectorName,
+                rdns: "sol.wallet.".concat(connectorName.toLowerCase().replace(/\s+/g, "")),
+            }).catch(function (error) {
+                logger_1.logger.error("SolanaStoreHandler: Error emitting connect", error);
+            });
+        }
+    };
+    SolanaStoreHandler.prototype.handleDisconnect = function () {
+        if (!this.lastAddress) {
+            return;
+        }
+        logger_1.logger.info("SolanaStoreHandler: Wallet disconnected", {
+            address: this.lastAddress,
+            chainId: this.lastChainId,
+        });
+        if (this.formo.isAutocaptureEnabled("disconnect")) {
+            this.formo.disconnect({
+                chainId: this.lastChainId,
+                address: this.lastAddress,
+            }).catch(function (error) {
+                logger_1.logger.error("SolanaStoreHandler: Error emitting disconnect", error);
+            });
+        }
+        this.lastAddress = undefined;
+        this.lastChainId = undefined;
+    };
+    // ============================================================
+    // Cluster Subscription
+    // ============================================================
+    SolanaStoreHandler.prototype.setupClusterSubscription = function () {
+        var _this = this;
+        var prevEndpoint = this.store.getState().cluster.endpoint;
+        var unsubscribe = this.store.subscribe(function (state) {
+            var endpoint = state.cluster.endpoint;
+            if (endpoint !== prevEndpoint) {
+                prevEndpoint = endpoint;
+                _this.handleClusterChange(endpoint);
+            }
+        });
+        this.unsubscribers.push(unsubscribe);
+        logger_1.logger.info("SolanaStoreHandler: Cluster subscription set up");
+    };
+    SolanaStoreHandler.prototype.handleClusterChange = function (endpoint) {
+        // Don't auto-detect if the cluster was explicitly set
+        if (this.explicitCluster) {
+            return;
+        }
+        var detected = this.detectClusterFromEndpoint(endpoint);
+        if (!detected) {
+            return;
+        }
+        var previousCluster = this.cluster;
+        if (detected === previousCluster) {
+            return;
+        }
+        this.cluster = detected;
+        this.chainId = types_1.SOLANA_CHAIN_IDS[detected];
+        logger_1.logger.info("SolanaStoreHandler: Cluster changed", {
+            from: previousCluster,
+            to: detected,
+            chainId: this.chainId,
+        });
+        if (this.lastAddress) {
+            this.lastChainId = this.chainId;
+            if (this.formo.isAutocaptureEnabled("chain")) {
+                this.formo.chain({
+                    chainId: this.chainId,
+                    address: this.lastAddress,
+                }).catch(function (error) {
+                    logger_1.logger.error("SolanaStoreHandler: Error emitting chain event", error);
+                });
+            }
+        }
+    };
+    // ============================================================
+    // Transaction Subscription
+    // ============================================================
+    SolanaStoreHandler.prototype.setupTransactionSubscription = function () {
+        var _this = this;
+        var prevTransactions = this.store.getState().transactions;
+        var unsubscribe = this.store.subscribe(function (state) {
+            var transactions = state.transactions;
+            if (transactions !== prevTransactions) {
+                var prev = prevTransactions;
+                prevTransactions = transactions;
+                _this.handleTransactionChanges(transactions, prev);
+            }
+        });
+        this.unsubscribers.push(unsubscribe);
+        logger_1.logger.info("SolanaStoreHandler: Transaction subscription set up");
+    };
+    SolanaStoreHandler.prototype.handleTransactionChanges = function (transactions, prevTransactions) {
+        var _a;
+        // Check each transaction for status changes
+        for (var _i = 0, _b = Object.entries(transactions); _i < _b.length; _i++) {
+            var _c = _b[_i], key = _c[0], tx = _c[1];
+            var prevTx = prevTransactions[key];
+            // Skip if status hasn't changed
+            if (prevTx && prevTx.status === tx.status) {
+                continue;
+            }
+            // For new transactions (sending), use current address.
+            // For terminal states, fall back to the address captured at STARTED time.
+            var address = this.lastAddress || ((_a = this.transactionSenders.get(key)) === null || _a === void 0 ? void 0 : _a.address);
+            if (!address) {
+                continue;
+            }
+            this.handleTransactionStatusChange(key, tx, prevTx, address);
+        }
+    };
+    SolanaStoreHandler.prototype.handleTransactionStatusChange = function (key, tx, prevTx, address) {
+        var chainId = this.chainId;
+        var dedupeKey = "".concat(key, ":").concat(tx.status);
+        // Deduplicate
+        if (this.processedTransactions.has(dedupeKey)) {
+            return;
+        }
+        this.processedTransactions.add(dedupeKey);
+        cleanupOldEntries(this.processedTransactions);
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        switch (tx.status) {
+            case "sending": {
+                // Emit STARTED when transaction enters "sending" state
+                if (!this.startedTransactions.has(key)) {
+                    this.startedTransactions.add(key);
+                    cleanupOldEntries(this.startedTransactions);
+                    // Capture sender for this transaction so terminal events are attributed
+                    // correctly even if the wallet disconnects before the tx settles.
+                    this.transactionSenders.set(key, { address: address, chainId: chainId });
+                    this.formo.transaction({
+                        status: events_1.TransactionStatus.STARTED,
+                        chainId: chainId,
+                        address: address,
+                    }).catch(function (error) {
+                        logger_1.logger.error("SolanaStoreHandler: Error emitting transaction STARTED", error);
+                    });
+                }
+                break;
+            }
+            case "waiting": {
+                // "waiting" means the tx was sent and we have a signature — emit BROADCASTED
+                var signature = tx.signature;
+                if (signature) {
+                    // Ensure sender is captured (in case we missed "sending")
+                    if (!this.transactionSenders.has(key)) {
+                        this.transactionSenders.set(key, { address: address, chainId: chainId });
+                    }
+                    var sender = this.transactionSenders.get(key);
+                    this.formo.transaction({
+                        status: events_1.TransactionStatus.BROADCASTED,
+                        chainId: sender.chainId,
+                        address: sender.address,
+                        transactionHash: signature,
+                    }).catch(function (error) {
+                        logger_1.logger.error("SolanaStoreHandler: Error emitting transaction BROADCASTED", error);
+                    });
+                }
+                break;
+            }
+            case "confirmed": {
+                var sender = this.transactionSenders.get(key);
+                var txAddress = (sender === null || sender === void 0 ? void 0 : sender.address) || address;
+                var txChainId = (sender === null || sender === void 0 ? void 0 : sender.chainId) || chainId;
+                var signature = tx.signature;
+                logger_1.logger.info("SolanaStoreHandler: Transaction confirmed", {
+                    key: key,
+                    signature: signature,
+                });
+                this.formo.transaction(__assign({ status: events_1.TransactionStatus.CONFIRMED, chainId: txChainId, address: txAddress }, (signature && { transactionHash: signature }))).catch(function (error) {
+                    logger_1.logger.error("SolanaStoreHandler: Error emitting transaction CONFIRMED", error);
+                });
+                this.transactionSenders.delete(key);
+                break;
+            }
+            case "failed": {
+                var sender = this.transactionSenders.get(key);
+                var txAddress = (sender === null || sender === void 0 ? void 0 : sender.address) || address;
+                var txChainId = (sender === null || sender === void 0 ? void 0 : sender.chainId) || chainId;
+                var signature = tx.signature;
+                var prevStatus = prevTx === null || prevTx === void 0 ? void 0 : prevTx.status;
+                // If it failed after being sent and confirmed as failed on-chain, emit REVERTED.
+                // Otherwise (rejected by user, build error, RPC rejection), emit REJECTED.
+                var status_1 = prevStatus === "waiting"
+                    ? events_1.TransactionStatus.REVERTED
+                    : events_1.TransactionStatus.REJECTED;
+                logger_1.logger.info("SolanaStoreHandler: Transaction failed", {
+                    key: key,
+                    signature: signature,
+                    status: status_1,
+                    prevStatus: prevStatus,
+                });
+                this.formo.transaction(__assign({ status: status_1, chainId: txChainId, address: txAddress }, (signature && { transactionHash: signature }))).catch(function (error) {
+                    logger_1.logger.error("SolanaStoreHandler: Error emitting transaction event", error);
+                });
+                this.transactionSenders.delete(key);
+                break;
+            }
+            // "idle" — no event needed
+        }
+    };
+    // ============================================================
+    // Cluster Detection
+    // ============================================================
+    /**
+     * Attempt to detect the Solana cluster from the store's endpoint URL.
+     */
+    SolanaStoreHandler.prototype.detectClusterFromStore = function (store) {
+        try {
+            var endpoint = store.getState().cluster.endpoint;
+            return this.detectClusterFromEndpoint(endpoint);
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    /**
+     * Detect cluster from an RPC endpoint URL.
+     */
+    SolanaStoreHandler.prototype.detectClusterFromEndpoint = function (endpoint) {
+        if (!endpoint)
+            return null;
+        var lower = endpoint.toLowerCase();
+        if (lower.includes("devnet"))
+            return "devnet";
+        if (lower.includes("testnet"))
+            return "testnet";
+        if (lower.includes("localhost") || lower.includes("127.0.0.1"))
+            return "localnet";
+        if (lower.includes("mainnet"))
+            return "mainnet-beta";
+        return null;
+    };
+    // ============================================================
+    // Cleanup
+    // ============================================================
+    SolanaStoreHandler.prototype.cleanup = function () {
+        logger_1.logger.debug("SolanaStoreHandler: Cleaning up");
+        for (var _i = 0, _a = this.unsubscribers; _i < _a.length; _i++) {
+            var unsubscribe = _a[_i];
+            try {
+                unsubscribe();
+            }
+            catch (error) {
+                logger_1.logger.error("SolanaStoreHandler: Error during cleanup", error);
+            }
+        }
+        this.unsubscribers = [];
+        this.processedTransactions.clear();
+        this.startedTransactions.clear();
+        this.transactionSenders.clear();
+        this.lastAddress = undefined;
+        this.lastChainId = undefined;
+        logger_1.logger.debug("SolanaStoreHandler: Cleanup complete");
+    };
+    return SolanaStoreHandler;
+}());
+exports.SolanaStoreHandler = SolanaStoreHandler;
+//# sourceMappingURL=SolanaStoreHandler.js.map

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

@@ -1,13 +1,17 @@
 /**
  * Solana integration module
  *
- * Provides integration with Solana Wallet Adapter for wallet event tracking.
- * This module exports the SolanaAdapter and related types.
+ * Provides automatic event capture for Solana wallets via framework-kit's
+ * zustand store. Connect/disconnect and transaction events are tracked
+ * automatically. Signature events (signMessage/signTransaction) require
+ * explicit tracking via formo.signature() since framework-kit
+ * doesn't track these in store state.
  *
- * @see https://github.com/anza-xyz/wallet-adapter
+ * @see https://github.com/solana-foundation/framework-kit
  */
-export { SolanaAdapter } from "./SolanaAdapter";
+export { SolanaStoreHandler } from "./SolanaStoreHandler";
 export { SolanaManager } from "./SolanaManager";
 export * from "./types";
+export * from "./storeTypes";
 export * from "./address";
 //# sourceMappingURL=index.d.ts.map

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

@@ -2,10 +2,13 @@
 /**
  * Solana integration module
  *
- * Provides integration with Solana Wallet Adapter for wallet event tracking.
- * This module exports the SolanaAdapter and related types.
+ * Provides automatic event capture for Solana wallets via framework-kit's
+ * zustand store. Connect/disconnect and transaction events are tracked
+ * automatically. Signature events (signMessage/signTransaction) require
+ * explicit tracking via formo.signature() since framework-kit
+ * doesn't track these in store state.
  *
- * @see https://github.com/anza-xyz/wallet-adapter
+ * @see https://github.com/solana-foundation/framework-kit
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -22,11 +25,12 @@ 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; } });
+exports.SolanaManager = exports.SolanaStoreHandler = void 0;
+var SolanaStoreHandler_1 = require("./SolanaStoreHandler");
+Object.defineProperty(exports, "SolanaStoreHandler", { enumerable: true, get: function () { return SolanaStoreHandler_1.SolanaStoreHandler; } });
 var SolanaManager_1 = require("./SolanaManager");
 Object.defineProperty(exports, "SolanaManager", { enumerable: true, get: function () { return SolanaManager_1.SolanaManager; } });
 __exportStar(require("./types"), exports);
+__exportStar(require("./storeTypes"), exports);
 __exportStar(require("./address"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,107 @@
+/**
+ * Type definitions for framework-kit's zustand store integration.
+ *
+ * These types mirror the state shape of @solana-foundation/framework-kit's
+ * vanilla zustand store, allowing the SDK to subscribe to wallet and
+ * transaction state changes without wrapping any wallet methods.
+ *
+ * @see https://github.com/solana-foundation/framework-kit
+ */
+/**
+ * The complete framework-kit client state shape.
+ * We only type the fields we subscribe to.
+ */
+export interface SolanaClientState {
+    transactions: SolanaTransactionState;
+    wallet: SolanaWalletStatus;
+    cluster: SolanaClusterState;
+    lastUpdatedAt: number;
+}
+/**
+ * Transaction records keyed by signature.
+ */
+export type SolanaTransactionState = Record<string, SolanaTransactionRecord>;
+/**
+ * Individual transaction record in the store.
+ */
+export interface SolanaTransactionRecord {
+    readonly error?: unknown;
+    readonly lastUpdatedAt: number;
+    readonly signature?: string;
+    readonly status: "idle" | "sending" | "waiting" | "confirmed" | "failed";
+}
+/**
+ * Wallet status — discriminated union.
+ */
+export type SolanaWalletStatus = SolanaWalletDisconnected | SolanaWalletConnecting | SolanaWalletConnected | SolanaWalletError;
+export interface SolanaWalletDisconnected {
+    readonly status: "disconnected";
+}
+export interface SolanaWalletConnecting {
+    readonly status: "connecting";
+    readonly connectorId: string;
+    readonly autoConnect?: boolean;
+}
+export interface SolanaWalletConnected {
+    readonly status: "connected";
+    readonly connectorId: string;
+    readonly session: SolanaWalletSession;
+    readonly autoConnect?: boolean;
+}
+export interface SolanaWalletError {
+    readonly status: "error";
+    readonly connectorId?: string;
+    readonly error: unknown;
+    readonly autoConnect?: boolean;
+}
+/**
+ * Wallet session — carries the connected wallet's capabilities and account.
+ */
+export interface SolanaWalletSession {
+    readonly account: SolanaWalletAccount;
+    readonly connector: SolanaWalletConnectorMetadata;
+    disconnect(): Promise<void>;
+}
+export interface SolanaWalletAccount {
+    readonly address: string;
+    readonly label?: string;
+    readonly publicKey?: unknown;
+}
+export interface SolanaWalletConnectorMetadata {
+    readonly id: string;
+    readonly name: string;
+    readonly icon?: string;
+}
+/**
+ * Cluster state from the store.
+ */
+export interface SolanaClusterState {
+    readonly endpoint: string;
+    readonly commitment?: string;
+    readonly status: "idle" | "connecting" | "ready" | "error";
+}
+/**
+ * The zustand vanilla store API that framework-kit exposes via `client.store`.
+ *
+ * Note: framework-kit's store uses vanilla zustand without the
+ * `subscribeWithSelector` middleware, so only the single-argument
+ * subscribe form (full-state listener) is supported.
+ */
+export interface SolanaClientStore {
+    getState(): SolanaClientState;
+    /**
+     * Subscribe to all state changes.
+     */
+    subscribe(listener: (state: SolanaClientState, prevState: SolanaClientState) => void): () => void;
+}
+/**
+ * Options for configuring the store-based Solana integration.
+ */
+export interface SolanaStoreOptions {
+    /**
+     * The framework-kit client store (client.store).
+     * This is a vanilla zustand store that tracks wallet, transaction, and cluster state.
+     */
+    store: SolanaClientStore;
+}
+//# sourceMappingURL=storeTypes.d.ts.map

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

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Type definitions for framework-kit's zustand store integration.
+ *
+ * These types mirror the state shape of @solana-foundation/framework-kit's
+ * vanilla zustand store, allowing the SDK to subscribe to wallet and
+ * transaction state changes without wrapping any wallet methods.
+ *
+ * @see https://github.com/solana-foundation/framework-kit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=storeTypes.js.map