@formo/analytics 1.38.2 → 1.40.0

package/dist/cjs/src/evm/EvmEventTracker.d.ts

@@ -11,6 +11,8 @@ export interface EvmEventTrackerDeps {
     isTrackingSuppressed(): boolean;
     /** Whether an event on this chain would actually be sent. */
     willTrackEvent(chainId?: ChainID): boolean;
+    /** Retry detect events after the active chain changes. */
+    retryDetection(): void;
     /** In wagmi mode the SDK does not wrap providers itself. */
     isWagmiMode(): boolean;
     /** Emission. The tracker decides WHEN; the SDK owns the event API. */
@@ -152,6 +154,8 @@ export declare class EvmEventTracker {
      * had already replaced.
      */
     private unsubscribeDiscovery?;
+    /** Discovery store retained for complete listener cleanup. */
+    private discoveryStore?;
     constructor(wallet: WalletStateStore, registry: EvmProviderRegistry, deps: EvmEventTrackerDeps);
     /** Stop listening for wallet announcements. Called from SDK teardown. */
     cleanup(): void;
@@ -259,8 +263,11 @@ export declare class EvmEventTracker {
     private registerConnectListener;
     private registerDisconnectListener;
     private onConnected;
+    /** Whether Formo owns provider lifecycle tracking. */
+    private tracksDiscovered;
     getProviders(): Promise<readonly EIP6963ProviderDetail[]>;
     detectWallets(providers: readonly EIP6963ProviderDetail[]): Promise<void>;
+    detectableProviders(): readonly EIP6963ProviderDetail[];
     /**
      * Seed a provider's chain from whatever it already exposes synchronously.
      *

package/dist/cjs/src/evm/EvmEventTracker.js

@@ -270,7 +270,7 @@ var EvmEventTracker = /** @class */ (function () {
     };
     /** Stop listening for wallet announcements. Called from SDK teardown. */
     EvmEventTracker.prototype.cleanup = function () {
-        var _a;
+        var _a, _b;
         // A replay in flight (awaiting the active wallet's accounts) must not
         // resume into a torn-down instance and commit a session there.
         this.disposed = true;
@@ -280,11 +280,13 @@ var EvmEventTracker = /** @class */ (function () {
         this.retryRequested = false;
         try {
             (_a = this.unsubscribeDiscovery) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.discoveryStore) === null || _b === void 0 ? void 0 : _b.destroy();
         }
         catch (e) {
             logger_1.logger.warn("Failed to unsubscribe from provider discovery", e);
         }
         this.unsubscribeDiscovery = undefined;
+        this.discoveryStore = undefined;
     };
     EvmEventTracker.prototype.sessionGeneration = function (provider) {
         var _a;
@@ -1018,6 +1020,7 @@ var EvmEventTracker = /** @class */ (function () {
                             this.wallet.provider = provider;
                         }
                         this.wallet.set('evm', { chainId: nextChainId });
+                        this.deps.retryDetection();
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 5, , 6]);
@@ -1335,12 +1338,17 @@ var EvmEventTracker = /** @class */ (function () {
             });
         });
     };
+    /** Whether Formo owns provider lifecycle tracking. */
+    EvmEventTracker.prototype.tracksDiscovered = function () {
+        return !this.deps.isWagmiMode();
+    };
     EvmEventTracker.prototype.getProviders = function () {
         return __awaiter(this, void 0, void 0, function () {
             var store, providers, injected, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
             var _this = this;
             return __generator(this, function (_a) {
                 store = (0, mipd_1.createStore)();
+                this.discoveryStore = store;
                 providers = store.getProviders();
                 this.unsubscribeDiscovery = store.subscribe(function (providerDetails) {
                     providers = providerDetails;
@@ -1359,8 +1367,12 @@ var EvmEventTracker = /** @class */ (function () {
                         var p = detail === null || detail === void 0 ? void 0 : detail.provider;
                         return !!p && !_this.registry.isTracked(p);
                     });
-                    if (newDetails.length > 0) {
+                    // Wagmi detects only providers added by this announcement.
+                    var toDetect = _this.tracksDiscovered() ? newDetails : newlyAddedDetails;
+                    if (_this.tracksDiscovered() && newDetails.length > 0) {
                         _this.trackProviders(newDetails);
+                    }
+                    if (toDetect.length > 0) {
                         // Detect newly discovered wallets (session de-dupes) with error handling
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var e_3;
@@ -1368,7 +1380,7 @@ var EvmEventTracker = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.detectWallets(newDetails)];
+                                        return [4 /*yield*/, this.detectWallets(toDetect)];
                                     case 1:
                                         _a.sent();
                                         return [3 /*break*/, 3];
@@ -1394,7 +1406,7 @@ var EvmEventTracker = /** @class */ (function () {
                         if (this.registry.injected &&
                             this.registry.injected.provider === injected) {
                             // Ensure it's tracked
-                            if (!this.registry.isTracked(injected)) {
+                            if (this.tracksDiscovered() && !this.registry.isTracked(injected)) {
                                 this.trackEIP1193Provider(injected);
                             }
                             // Merge with existing providers instead of overwriting
@@ -1402,7 +1414,7 @@ var EvmEventTracker = /** @class */ (function () {
                             return [2 /*return*/, this.registry.all];
                         }
                         // Re-check if the injected provider is already tracked just before tracking
-                        if (!this.registry.isTracked(injected)) {
+                        if (this.tracksDiscovered() && !this.registry.isTracked(injected)) {
                             this.trackEIP1193Provider(injected);
                         }
                         injectedProviderInfo = (0, provider_1.detectInjectedProviderInfo)(injected);
@@ -1462,6 +1474,20 @@ var EvmEventTracker = /** @class */ (function () {
             });
         });
     };
+    EvmEventTracker.prototype.detectableProviders = function () {
+        var _a;
+        var available = new Set();
+        (_a = this.discoveryStore) === null || _a === void 0 ? void 0 : _a.getProviders().forEach(function (detail) {
+            return available.add(detail.provider);
+        });
+        var injected = typeof window !== "undefined" ? window.ethereum : undefined;
+        if (injected)
+            available.add(injected);
+        this.externallyRegistered.forEach(function (provider) { return available.add(provider); });
+        return this.registry.all.filter(function (detail) {
+            return available.has(detail.provider);
+        });
+    };
     /**
      * Seed a provider's chain from whatever it already exposes synchronously.
      *

package/dist/cjs/src/queue/EventQueue.d.ts

@@ -28,6 +28,7 @@ export declare class EventQueue implements IEventQueue {
     private pendingFlush;
     private payloadHashes;
     private canSend?;
+    private generation;
     private closed;
     private disposePageLeave;
     constructor(writeKey: string, options: Options);

package/dist/cjs/src/queue/EventQueue.js

@@ -89,6 +89,7 @@ var EventQueue = /** @class */ (function () {
         this.queue = [];
         this.queueByteSize = 0; // running total of queued items' byteSize
         this.payloadHashes = new Set();
+        this.generation = 0;
         // Terminal shutdown flag. Once set, enqueue() and flush() are no-ops for
         // the rest of this instance's life. See close().
         this.closed = false;
@@ -222,6 +223,7 @@ var EventQueue = /** @class */ (function () {
      * withdrawal / SDK teardown so nothing buffered can be sent later.
      */
     EventQueue.prototype.clear = function () {
+        this.generation++;
         if (this.timer) {
             clearTimeout(this.timer);
             this.timer = null;
@@ -229,6 +231,8 @@ var EventQueue = /** @class */ (function () {
         this.queue = [];
         this.queueByteSize = 0;
         this.payloadHashes.clear();
+        this.flushed = false;
+        this.pendingFlush = null;
     };
     /**
      * Terminal shutdown. Unlike clear(), which only empties the buffer and can
@@ -265,11 +269,12 @@ var EventQueue = /** @class */ (function () {
     });
     EventQueue.prototype.enqueue = function (event, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var message_id, queueItem, hasReachedFlushAt, hasReachedQueueSize;
+            var generation, message_id, queueItem, hasReachedFlushAt, hasReachedQueueSize;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         callback = callback || noop;
+                        generation = this.generation;
                         // A torn-down instance must never buffer, however late the caller
                         // arrives. See close().
                         if (this.closed)
@@ -282,12 +287,12 @@ var EventQueue = /** @class */ (function () {
                         return [4 /*yield*/, this.generateMessageId(event)];
                     case 1:
                         message_id = _a.sent();
-                        // Re-check after the await. A caller that entered before close() is
-                        // suspended here, and on a queue that has not flushed yet its event
-                        // would push and flush immediately - the exact shape of the bug close()
-                        // exists to stop.
-                        if (this.closed)
+                        if (this.closed || generation !== this.generation)
                             return [2 /*return*/];
+                        if (this.canSend && !this.canSend()) {
+                            this.clear();
+                            return [2 /*return*/];
+                        }
                         // check if the message already exists
                         if (this.isDuplicate(message_id)) {
                             logger_1.logger.warn("Event already enqueued, try again after ".concat((0, utils_1.millisecondsToSecond)(this.flushIntervalMs), " seconds."));

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

@@ -1,14 +1,27 @@
 /**
  * SolanaManager
  *
- * Manages the lifecycle of the Solana store integration.
- * Subscribes to framework-kit's zustand store for automatic event capture
- * of wallet connect/disconnect and transaction lifecycle events.
+ * Owns the two ways the SDK learns about Solana wallets:
  *
- * For signMessage/signTransaction tracking (not captured by the store),
+ *  1. `SolanaWalletStandardRegistry`: discovers wallets through the Wallet
+ *     Standard and reports detect / connect / disconnect. On by default, so
+ *     compatible wallets registered by Solana Kit, wallet-adapter,
+ *     framework-kit, or another host are covered with no configuration,
+ *     exactly like EVM wallets through EIP-6963. `solana: false` turns it off.
+ *  2. `SolanaStoreHandler`: subscribes to framework-kit's zustand store for
+ *     connect / disconnect / cluster changes AND the transaction lifecycle.
+ *     Opt-in through `solana: { store }` or `formo.solana.setStore()`.
+ *
+ * Both observe the same Wallet Standard connection when a framework-kit app
+ * connects. A store supplied at initialization owns wallet events; a store
+ * attached later takes ownership when it observes its first connection and
+ * adopts any connect the registry already reported. One connect per
+ * connection, whichever path an app is on.
+ *
+ * For signMessage/signTransaction tracking (not captured by either path),
  * use formo.signature() directly with the address and chainId.
  *
- * For manual event tracking without the store, use the core API directly:
+ * For manual event tracking, use the core API directly:
  * formo.transaction(), formo.signature(), formo.connect(), formo.disconnect().
  */
 import { FormoAnalytics } from "../FormoAnalytics";
@@ -16,9 +29,19 @@ import { SolanaCluster, SolanaOptions } from "./types";
 import { SolanaClientStore } from "./storeTypes";
 export declare class SolanaManager {
     private formo;
+    private readonly enabled;
     private storeHandler?;
+    private registry?;
     private pendingCluster?;
-    constructor(formo: FormoAnalytics, options?: SolanaOptions);
+    private storeOwnsWalletEvents;
+    /**
+     * @param formo - The SDK instance events are reported to.
+     * @param options - `options.solana` as passed to the SDK, if an object.
+     * @param enabled - Whether Solana tracking is enabled. False only when the
+     *   host app passed `solana: false`; both discovery and stores then stay off.
+     */
+    constructor(formo: FormoAnalytics, options?: SolanaOptions, enabled?: boolean);
+    private attachStore;
     /**
      * Set the framework-kit zustand store for automatic event tracking.
      * This enables autocapture mode — connect/disconnect and transaction events
@@ -39,11 +62,16 @@ export declare class SolanaManager {
         cluster?: SolanaCluster;
     }): void;
     /**
-     * Update the cluster/network. Only needed if the store endpoint doesn't
-     * contain a recognizable cluster name (e.g. custom RPC URLs).
-     * In most cases, the cluster is auto-detected from the store's endpoint.
+     * Update the cluster/network.
+     *
+     * With a framework-kit store, only needed if the store endpoint doesn't
+     * contain a recognizable cluster name (e.g. custom RPC URLs). Without one,
+     * this is how a non-mainnet app tells the SDK which cluster its Wallet
+     * Standard connections are on, since the standard itself cannot say.
      */
     setCluster(cluster: SolanaCluster): void;
+    /** Names of the Wallet Standard wallets discovered so far. */
+    get discoveredWallets(): string[];
     cleanup(): void;
 }
 //# sourceMappingURL=SolanaManager.d.ts.map

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

@@ -2,34 +2,126 @@
 /**
  * SolanaManager
  *
- * Manages the lifecycle of the Solana store integration.
- * Subscribes to framework-kit's zustand store for automatic event capture
- * of wallet connect/disconnect and transaction lifecycle events.
+ * Owns the two ways the SDK learns about Solana wallets:
  *
- * For signMessage/signTransaction tracking (not captured by the store),
+ *  1. `SolanaWalletStandardRegistry`: discovers wallets through the Wallet
+ *     Standard and reports detect / connect / disconnect. On by default, so
+ *     compatible wallets registered by Solana Kit, wallet-adapter,
+ *     framework-kit, or another host are covered with no configuration,
+ *     exactly like EVM wallets through EIP-6963. `solana: false` turns it off.
+ *  2. `SolanaStoreHandler`: subscribes to framework-kit's zustand store for
+ *     connect / disconnect / cluster changes AND the transaction lifecycle.
+ *     Opt-in through `solana: { store }` or `formo.solana.setStore()`.
+ *
+ * Both observe the same Wallet Standard connection when a framework-kit app
+ * connects. A store supplied at initialization owns wallet events; a store
+ * attached later takes ownership when it observes its first connection and
+ * adopts any connect the registry already reported. One connect per
+ * connection, whichever path an app is on.
+ *
+ * For signMessage/signTransaction tracking (not captured by either path),
  * use formo.signature() directly with the address and chainId.
  *
- * For manual event tracking without the store, use the core API directly:
+ * For manual event tracking, use the core API directly:
  * formo.transaction(), formo.signature(), formo.connect(), formo.disconnect().
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaManager = void 0;
 var logger_1 = require("../logger");
 var SolanaStoreHandler_1 = require("./SolanaStoreHandler");
+var SolanaWalletStandardRegistry_1 = require("./SolanaWalletStandardRegistry");
+var types_1 = require("./types");
 var SolanaManager = /** @class */ (function () {
-    function SolanaManager(formo, options) {
+    /**
+     * @param formo - The SDK instance events are reported to.
+     * @param options - `options.solana` as passed to the SDK, if an object.
+     * @param enabled - Whether Solana tracking is enabled. False only when the
+     *   host app passed `solana: false`; both discovery and stores then stay off.
+     */
+    function SolanaManager(formo, options, enabled) {
+        if (enabled === void 0) { enabled = true; }
+        var _this = this;
         this.formo = formo;
-        if (options === null || options === void 0 ? void 0 : options.store) {
-            logger_1.logger.info("SolanaManager: Initializing store-based Solana tracking");
-            this.storeHandler = new SolanaStoreHandler_1.SolanaStoreHandler(formo, options.store, {
-                cluster: options.cluster,
-            });
-        }
-        else if (options === null || options === void 0 ? void 0 : options.cluster) {
+        this.enabled = enabled;
+        this.storeOwnsWalletEvents = false;
+        if (!enabled)
+            return;
+        if (options === null || options === void 0 ? void 0 : options.cluster) {
             // Store pending cluster for when setStore is called later
             this.pendingCluster = options.cluster;
         }
+        // A store supplied at initialization owns wallet events from the outset:
+        // unlike a store attached later, it has not missed any prior registry
+        // state and it knows the cluster more precisely.
+        this.storeOwnsWalletEvents = !!(options === null || options === void 0 ? void 0 : options.store);
+        this.registry = new SolanaWalletStandardRegistry_1.SolanaWalletStandardRegistry({
+            isAutocaptureEnabled: function (t) { return _this.formo.isAutocaptureEnabled(t); },
+            willTrackEvent: function (chainId) { return _this.formo.willTrackEvent(chainId); },
+            detect: function (params) { return _this.formo.detect(params); },
+            connect: function (params, properties) {
+                return _this.formo.connect(params, properties);
+            },
+            disconnect: function (params) { return _this.formo.disconnect(params); },
+            chain: function (params) { return _this.formo.chain(params); },
+            syncWalletState: function (params) { return _this.formo.syncWalletState(params); },
+            currentAddress: function () { return _this.formo.currentAddress; },
+            ownsWalletEvents: function () { return !_this.storeOwnsWalletEvents; },
+        }, { cluster: options === null || options === void 0 ? void 0 : options.cluster });
+        if (options === null || options === void 0 ? void 0 : options.store) {
+            logger_1.logger.info("SolanaManager: Initializing store-based Solana tracking");
+            this.attachStore(options.store, options.cluster);
+        }
     }
+    SolanaManager.prototype.attachStore = function (store, cluster) {
+        var _this = this;
+        var _a;
+        this.storeHandler = new SolanaStoreHandler_1.SolanaStoreHandler(this.formo, store, {
+            cluster: cluster,
+            beforeWalletConnect: function (connection) {
+                var _a, _b;
+                // The store's cluster is authoritative even when chain autocapture is
+                // disabled. Keep central attribution correct without manufacturing a
+                // chain event in that mode.
+                _this.formo.syncWalletState({
+                    address: connection.address,
+                    chainId: connection.chainId,
+                });
+                if (_this.storeOwnsWalletEvents)
+                    return true;
+                var reported = (_a = _this.registry) === null || _a === void 0 ? void 0 : _a.takeReportedConnection(connection.address, connection.rdns);
+                _this.storeOwnsWalletEvents = true;
+                // If Wallet Standard got there first, the store adopts that live
+                // connection instead of emitting it again. Correct its cluster if
+                // the store has more precise information.
+                if (!reported) {
+                    // Nothing to adopt. Either the registry never reported this
+                    // connection, or it reported it under another identity, in which
+                    // case the store is about to emit a second connect for the same
+                    // live connection. Both paths derive the rdns from the wallet's
+                    // own name, so a mismatch means the store's connector is labelled
+                    // differently from the registered wallet.
+                    var held = (_b = _this.registry) === null || _b === void 0 ? void 0 : _b.reportedConnectionRdns(connection.address);
+                    if (held) {
+                        logger_1.logger.warn("SolanaManager: Store connector does not match the discovered wallet; the connection is reported twice", { storeRdns: connection.rdns, walletRdns: held });
+                    }
+                    return true;
+                }
+                if (reported.chainId !== connection.chainId &&
+                    _this.formo.isAutocaptureEnabled("chain")) {
+                    _this.formo.chain(connection).catch(function (error) {
+                        logger_1.logger.error("SolanaManager: Error correcting cluster during store handoff", error);
+                    });
+                }
+                return false;
+            },
+        });
+        // Keep the registry's snapshot on the store's detected cluster. This is
+        // silent once the store owns events; during a late handoff it corrects a
+        // registry-reported connection before the store adopts it.
+        var detectedCluster = types_1.SOLANA_CLUSTERS_BY_ID[this.storeHandler.getChainId()];
+        if (detectedCluster)
+            (_a = this.registry) === null || _a === void 0 ? void 0 : _a.setCluster(detectedCluster);
+    };
     /**
      * Set the framework-kit zustand store for automatic event tracking.
      * This enables autocapture mode — connect/disconnect and transaction events
@@ -48,29 +140,52 @@ var SolanaManager = /** @class */ (function () {
      */
     SolanaManager.prototype.setStore = function (store, options) {
         var _a;
+        if (!this.enabled) {
+            logger_1.logger.warn("SolanaManager: Ignoring setStore. Solana tracking is off for this instance (solana: false, or the SDK was cleaned up)");
+            return;
+        }
         (_a = this.storeHandler) === null || _a === void 0 ? void 0 : _a.cleanup();
-        this.storeHandler = new SolanaStoreHandler_1.SolanaStoreHandler(this.formo, store, {
-            cluster: (options === null || options === void 0 ? void 0 : options.cluster) || this.pendingCluster,
-        });
+        this.storeHandler = undefined;
+        this.storeOwnsWalletEvents = false;
+        this.attachStore(store, (options === null || options === void 0 ? void 0 : options.cluster) || this.pendingCluster);
         this.pendingCluster = undefined;
     };
     /**
-     * Update the cluster/network. Only needed if the store endpoint doesn't
-     * contain a recognizable cluster name (e.g. custom RPC URLs).
-     * In most cases, the cluster is auto-detected from the store's endpoint.
+     * Update the cluster/network.
+     *
+     * With a framework-kit store, only needed if the store endpoint doesn't
+     * contain a recognizable cluster name (e.g. custom RPC URLs). Without one,
+     * this is how a non-mainnet app tells the SDK which cluster its Wallet
+     * Standard connections are on, since the standard itself cannot say.
      */
     SolanaManager.prototype.setCluster = function (cluster) {
+        var _a;
+        if (!this.enabled)
+            return;
         if (this.storeHandler) {
             this.storeHandler.setCluster(cluster);
         }
         else {
             this.pendingCluster = cluster;
         }
+        (_a = this.registry) === null || _a === void 0 ? void 0 : _a.setCluster(cluster);
     };
+    Object.defineProperty(SolanaManager.prototype, "discoveredWallets", {
+        /** Names of the Wallet Standard wallets discovered so far. */
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.registry) === null || _a === void 0 ? void 0 : _a.walletNames) !== null && _b !== void 0 ? _b : [];
+        },
+        enumerable: false,
+        configurable: true
+    });
     SolanaManager.prototype.cleanup = function () {
-        var _a;
+        var _a, _b;
         (_a = this.storeHandler) === null || _a === void 0 ? void 0 : _a.cleanup();
         this.storeHandler = undefined;
+        this.storeOwnsWalletEvents = false;
+        (_b = this.registry) === null || _b === void 0 ? void 0 : _b.cleanup();
+        this.registry = undefined;
     };
     return SolanaManager;
 }());

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

@@ -48,8 +48,14 @@ export declare class SolanaStoreHandler {
      * When true, auto-detection from the store endpoint is disabled.
      */
     private explicitCluster;
+    private beforeWalletConnect?;
     constructor(formoAnalytics: FormoAnalytics, store: SolanaClientStore, options?: {
         cluster?: SolanaCluster;
+        beforeWalletConnect?: (connection: {
+            address: string;
+            chainId: number;
+            rdns: string;
+        }) => boolean;
     });
     /**
      * Update the cluster/network.

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

@@ -69,6 +69,7 @@ var SolanaStoreHandler = /** @class */ (function () {
         this.formo = formoAnalytics;
         this.store = store;
         this.explicitCluster = !!(options === null || options === void 0 ? void 0 : options.cluster);
+        this.beforeWalletConnect = options === null || options === void 0 ? void 0 : options.beforeWalletConnect;
         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", {
@@ -141,7 +142,7 @@ var SolanaStoreHandler = /** @class */ (function () {
         logger_1.logger.info("SolanaStoreHandler: Wallet subscription set up");
     };
     SolanaStoreHandler.prototype.checkInitialWalletState = function () {
-        var _a;
+        var _a, _b, _c;
         var state = this.store.getState();
         var wallet = state.wallet;
         if (wallet.status === "connected") {
@@ -154,11 +155,17 @@ var SolanaStoreHandler = /** @class */ (function () {
                     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;
+                var connectorName = ((_a = wallet.session.connector) === null || _a === void 0 ? void 0 : _a.name) || wallet.connectorId;
+                var rdns = (0, types_1.solanaWalletRdns)(connectorName);
+                var shouldEmit = (_c = (_b = this.beforeWalletConnect) === null || _b === void 0 ? void 0 : _b.call(this, {
+                    address: address,
+                    chainId: this.chainId,
+                    rdns: rdns,
+                })) !== null && _c !== void 0 ? _c : true;
+                if (shouldEmit && this.formo.isAutocaptureEnabled("connect")) {
                     this.formo.connect({ chainId: this.chainId, address: address }, {
                         providerName: connectorName,
-                        rdns: "sol.wallet.".concat(connectorName.toLowerCase().replace(/\s+/g, "")),
+                        rdns: rdns,
                     }).catch(function (error) {
                         logger_1.logger.error("SolanaStoreHandler: Error emitting initial connect", error);
                     });
@@ -190,7 +197,7 @@ var SolanaStoreHandler = /** @class */ (function () {
         this.lastWalletStatus = wallet.status;
     };
     SolanaStoreHandler.prototype.handleConnect = function (wallet) {
-        var _a;
+        var _a, _b, _c;
         var address = wallet.session.account.address;
         if (!address || (0, address_1.isBlockedSolanaAddress)(address)) {
             return;
@@ -206,11 +213,13 @@ var SolanaStoreHandler = /** @class */ (function () {
             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;
+        var connectorName = ((_a = wallet.session.connector) === null || _a === void 0 ? void 0 : _a.name) || wallet.connectorId;
+        var rdns = (0, types_1.solanaWalletRdns)(connectorName);
+        var shouldEmit = (_c = (_b = this.beforeWalletConnect) === null || _b === void 0 ? void 0 : _b.call(this, { address: address, chainId: chainId, rdns: rdns })) !== null && _c !== void 0 ? _c : true;
+        if (shouldEmit && this.formo.isAutocaptureEnabled("connect")) {
             this.formo.connect({ chainId: chainId, address: address }, {
                 providerName: connectorName,
-                rdns: "sol.wallet.".concat(connectorName.toLowerCase().replace(/\s+/g, "")),
+                rdns: rdns,
             }).catch(function (error) {
                 logger_1.logger.error("SolanaStoreHandler: Error emitting connect", error);
             });