@formo/analytics 1.38.2 → 1.39.0

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

@@ -0,0 +1,54 @@
+/**
+ * The subset of the Wallet Standard this SDK reads.
+ *
+ * Duck-typed on purpose: the SDK must not depend on `@wallet-standard/*`
+ * packages (see the dependency policy), and a wallet is discovered through
+ * window events, so nothing here is ever imported from a wallet library.
+ * Every field is what a conforming wallet exposes; the shapes are looser
+ * than the reference types so a slightly off wallet is skipped, not thrown
+ * on.
+ *
+ * @see https://github.com/wallet-standard/wallet-standard
+ */
+/** `namespace:reference`, e.g. `solana:mainnet` or `solana:devnet`. */
+export type WalletStandardChain = string;
+export interface WalletStandardAccount {
+    readonly address: string;
+    readonly publicKey?: unknown;
+    /** Chains this account can sign for. Absent on a non-conforming wallet. */
+    readonly chains?: readonly WalletStandardChain[];
+    readonly features?: readonly string[];
+    readonly label?: string;
+    readonly icon?: string;
+}
+export interface WalletStandardWallet {
+    readonly version?: string;
+    readonly name: string;
+    readonly icon?: string;
+    /** Every chain the wallet supports, NOT the one currently selected. */
+    readonly chains: readonly WalletStandardChain[];
+    readonly features: Readonly<Record<string, unknown>>;
+    /** Accounts the app is currently authorized for; empty until connected. */
+    readonly accounts: readonly WalletStandardAccount[];
+}
+/** What a `standard:events` `change` event carries: only what changed. */
+export interface WalletStandardChangeProperties {
+    readonly chains?: readonly WalletStandardChain[];
+    readonly features?: Readonly<Record<string, unknown>>;
+    readonly accounts?: readonly WalletStandardAccount[];
+}
+/** The `standard:events` feature. */
+export interface WalletStandardEventsFeature {
+    readonly version?: string;
+    on(event: "change", listener: (properties: WalletStandardChangeProperties) => void): () => void;
+}
+/** The API an app hands to wallets so they can announce themselves. */
+export interface WalletStandardRegisterApi {
+    register(...wallets: WalletStandardWallet[]): () => void;
+}
+/** Dispatched by the app on `window`; `detail` is the register API. */
+export declare const WALLET_STANDARD_APP_READY_EVENT = "wallet-standard:app-ready";
+/** Dispatched by a wallet on `window`; `detail` is a callback taking the API. */
+export declare const WALLET_STANDARD_REGISTER_WALLET_EVENT = "wallet-standard:register-wallet";
+export declare const WALLET_STANDARD_EVENTS_FEATURE = "standard:events";
+//# sourceMappingURL=walletStandardTypes.d.ts.map

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * The subset of the Wallet Standard this SDK reads.
+ *
+ * Duck-typed on purpose: the SDK must not depend on `@wallet-standard/*`
+ * packages (see the dependency policy), and a wallet is discovered through
+ * window events, so nothing here is ever imported from a wallet library.
+ * Every field is what a conforming wallet exposes; the shapes are looser
+ * than the reference types so a slightly off wallet is skipped, not thrown
+ * on.
+ *
+ * @see https://github.com/wallet-standard/wallet-standard
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALLET_STANDARD_EVENTS_FEATURE = exports.WALLET_STANDARD_REGISTER_WALLET_EVENT = exports.WALLET_STANDARD_APP_READY_EVENT = void 0;
+/** Dispatched by the app on `window`; `detail` is the register API. */
+exports.WALLET_STANDARD_APP_READY_EVENT = "wallet-standard:app-ready";
+/** Dispatched by a wallet on `window`; `detail` is a callback taking the API. */
+exports.WALLET_STANDARD_REGISTER_WALLET_EVENT = "wallet-standard:register-wallet";
+exports.WALLET_STANDARD_EVENTS_FEATURE = "standard:events";
+//# sourceMappingURL=walletStandardTypes.js.map

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

@@ -246,16 +246,26 @@ export interface Options {
      */
     wagmi?: WagmiOptions;
     /**
-     * Solana integration configuration.
-     * Pass `store: client.store` from framework-kit for automatic tracking of
-     * wallet connect/disconnect and transaction events.
+     * Solana wallet tracking.
+     *
+     * On by default: wallets are discovered through the Wallet Standard, the
+     * Solana analogue of EIP-6963, so connect and disconnect are autocaptured
+     * for compatible wallets registered with the page, including wallets used
+     * through Solana Kit, wallet-adapter, and framework-kit.
+     *
+     * - `false`: disable Solana wallet discovery and tracking entirely.
+     * - `SolanaOptions`: additionally pass `store: client.store` from
+     *   framework-kit for transaction lifecycle events and cluster switches,
+     *   or `cluster` to name the network a non-mainnet app is on.
      *
      * For signMessage/signTransaction, use formo.signature() directly
-     * (framework-kit doesn't track these in the store).
+     * (neither the Wallet Standard nor framework-kit's store reports these).
      *
+     * @see https://github.com/wallet-standard/wallet-standard
      * @see https://github.com/solana-foundation/framework-kit
+     * @default true
      */
-    solana?: SolanaOptions;
+    solana?: boolean | SolanaOptions;
     /**
      * Custom API host for sending events through your own domain to bypass ad blockers
      * - If not provided, events are sent directly to events.formo.so

package/dist/cjs/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.38.2";
+export declare const version = "1.39.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/cjs/src/version.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-exports.version = '1.38.2';
+exports.version = '1.39.0';
 //# sourceMappingURL=version.js.map

package/dist/esm/src/FormoAnalytics.js

@@ -242,9 +242,12 @@ var FormoAnalytics = /** @class */ (function () {
                 this.evmEvents.trackEIP1193Provider(provider);
             }
         }
-        // Initialize Solana manager if Solana options are provided
-        if (options.solana) {
-            this.solanaManager = new SolanaManager(this, options.solana);
+        // Solana wallets are discovered through the Wallet Standard
+        // unconditionally, the way EVM wallets are through EIP-6963: an app
+        // that never configures Solana still gets its connects. `solana: false`
+        // is the opt-out; an object adds framework-kit's store or a cluster.
+        if (options.solana !== false) {
+            this.solanaManager = new SolanaManager(this, typeof options.solana === "object" ? options.solana : undefined);
         }
         this._currentUrl = window.location.href;
         // Seed currentAddress/currentChainId from the persisted snapshot before
@@ -1268,7 +1271,9 @@ var FormoAnalytics = /** @class */ (function () {
          */
         get: function () {
             if (!this.solanaManager) {
-                this.solanaManager = new SolanaManager(this);
+                // Only reachable after `solana: false` (or after cleanup). The host
+                // opted out of discovery, so this manager serves the store path only.
+                this.solanaManager = new SolanaManager(this, undefined, false);
             }
             return this.solanaManager;
         },

package/dist/esm/src/FormoAnalyticsProvider.js

@@ -69,6 +69,18 @@ var defaultContext = {
     hasOptedOutTracking: function () { return false; },
 };
 export var FormoAnalyticsContext = createContext(defaultContext);
+var optionObjectIds = new WeakMap();
+var nextOptionObjectId = 1;
+var optionObjectId = function (value) {
+    if (!value)
+        return undefined;
+    var id = optionObjectIds.get(value);
+    if (id === undefined) {
+        id = nextOptionObjectId++;
+        optionObjectIds.set(value, id);
+    }
+    return id;
+};
 /**
  * A stable key over the serializable parts of Options. The provider effect
  * re-initialises the SDK when this key changes; anything that alters SDK
@@ -92,6 +104,14 @@ export var computeOptionsKey = function (options) {
         logger: options.logger,
         referral: options.referral,
         evm: options.evm,
+        // `solana` is a boolean or an options object. A store is a live event
+        // source, so replacing it must reinitialize the SDK even when both the
+        // old and new options contain a store.
+        solana: typeof options.solana === "object" ? undefined : options.solana,
+        solanaStoreId: typeof options.solana === "object"
+            ? optionObjectId(options.solana.store)
+            : undefined,
+        solanaCluster: typeof options.solana === "object" ? options.solana.cluster : undefined,
         // For complex objects, just track their presence, not their content
         hasProvider: !!options.provider,
         hasWagmi: !!options.wagmi,

package/dist/esm/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/esm/src/solana/SolanaManager.js

@@ -1,32 +1,124 @@
 /**
  * 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 { logger } from "../logger";
 import { SolanaStoreHandler } from "./SolanaStoreHandler";
+import { SolanaWalletStandardRegistry } from "./SolanaWalletStandardRegistry";
+import { SOLANA_CLUSTERS_BY_ID, } from "./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.info("SolanaManager: Initializing store-based Solana tracking");
-            this.storeHandler = new 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({
+            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.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(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.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.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 = 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
@@ -45,29 +137,52 @@ var SolanaManager = /** @class */ (function () {
      */
     SolanaManager.prototype.setStore = function (store, options) {
         var _a;
+        if (!this.enabled) {
+            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(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/esm/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/esm/src/solana/SolanaStoreHandler.js

@@ -25,7 +25,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { TransactionStatus } from "../types/events";
 import { logger } from "../logger";
-import { SOLANA_CHAIN_IDS } from "./types";
+import { SOLANA_CHAIN_IDS, solanaWalletRdns, } from "./types";
 import { isBlockedSolanaAddress } from "./address";
 /**
  * Clean up old entries from a Set to prevent memory leaks.
@@ -66,6 +66,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 = SOLANA_CHAIN_IDS[this.cluster];
         logger.info("SolanaStoreHandler: Initializing framework-kit store integration", {
@@ -138,7 +139,7 @@ var SolanaStoreHandler = /** @class */ (function () {
         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") {
@@ -151,11 +152,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 = 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.error("SolanaStoreHandler: Error emitting initial connect", error);
                     });
@@ -187,7 +194,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 || isBlockedSolanaAddress(address)) {
             return;
@@ -203,11 +210,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 = 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.error("SolanaStoreHandler: Error emitting connect", error);
             });