@formo/analytics 1.38.1 → 1.39.0

package/dist/esm/src/evm/EvmProviderRegistry.d.ts

@@ -45,6 +45,24 @@ export declare class EvmProviderRegistry {
     private listeners;
     /** The window-injected provider, once detected, so it is not re-wrapped. */
     private injectedDetail?;
+    /**
+     * Attribution supplied by the integration layer for a provider that was
+     * never announced: the wagmi fallback wrap names a connector's provider
+     * after the CONNECTOR, so request-derived events carry the same wallet
+     * name as the hook-driven events from the same connection. Without it
+     * the name came from flag sniffing, and a custom or embedded connector
+     * whose provider exposes no recognised flag split one wallet's activity
+     * between "Injected Provider" and the connector's name.
+     *
+     * A RESOLVER, read at each `infoFor`, not a value: the name is live for
+     * the connector the integration layer bound it to (a WalletConnect
+     * session that resolves or changes its peer renames without a re-wrap),
+     * and the integration layer names events on its hook path with the same
+     * function, so the two paths cannot disagree. Which connector a
+     * provider is bound to is the integration layer's decision; it is not
+     * necessarily the connector that is current when the request runs.
+     */
+    private attributions;
     constructor(deps: EvmProviderRegistryDeps);
     get all(): readonly EIP6963ProviderDetail[];
     isTracked(provider: EIP1193Provider): boolean;
@@ -62,11 +80,25 @@ export declare class EvmProviderRegistry {
     };
     /** Add a discovered provider once. Returns false if already present. */
     add(detail: EIP6963ProviderDetail): boolean;
+    /**
+     * Record (or, with `undefined`, forget) the integration layer's own
+     * attribution resolver for a provider. See `attributions`.
+     */
+    rememberAttribution(provider: EIP1193Provider | undefined, resolve: (() => {
+        name: string;
+        rdns?: string;
+    } | undefined) | undefined): void;
+    /** The supplied attribution for a provider, if any resolves right now. */
+    private suppliedAttributionFor;
     /**
      * A provider's display name and rdns.
      *
-     * EIP-6963 metadata is authoritative when we have it; otherwise fall back to
-     * sniffing the injected provider, which is all a pre-6963 wallet offers.
+     * EIP-6963 metadata is authoritative when we have it. A supplied
+     * attribution (the connector a wagmi app connected through) comes next:
+     * it describes the SESSION, which is what the hook-driven events report.
+     * Otherwise fall back to sniffing the injected provider, which is all a
+     * pre-6963 wallet offers; a supplied name without an rdns keeps the
+     * sniffed rdns.
      */
     infoFor(provider: EIP1193Provider): {
         name: string;

package/dist/esm/src/evm/EvmProviderRegistry.js

@@ -74,6 +74,24 @@ var EvmProviderRegistry = /** @class */ (function () {
         this.chainGenerations = new WeakMap();
         /** Listeners this SDK attached, so teardown can remove exactly those. */
         this.listeners = new Map();
+        /**
+         * Attribution supplied by the integration layer for a provider that was
+         * never announced: the wagmi fallback wrap names a connector's provider
+         * after the CONNECTOR, so request-derived events carry the same wallet
+         * name as the hook-driven events from the same connection. Without it
+         * the name came from flag sniffing, and a custom or embedded connector
+         * whose provider exposes no recognised flag split one wallet's activity
+         * between "Injected Provider" and the connector's name.
+         *
+         * A RESOLVER, read at each `infoFor`, not a value: the name is live for
+         * the connector the integration layer bound it to (a WalletConnect
+         * session that resolves or changes its peer renames without a re-wrap),
+         * and the integration layer names events on its hook path with the same
+         * function, so the two paths cannot disagree. Which connector a
+         * provider is bound to is the integration layer's decision; it is not
+         * necessarily the connector that is current when the request runs.
+         */
+        this.attributions = new WeakMap();
     }
     Object.defineProperty(EvmProviderRegistry.prototype, "all", {
         // ── the provider set ─────────────────────────────────────────────────────
@@ -132,19 +150,55 @@ var EvmProviderRegistry = /** @class */ (function () {
         this.seen.add(provider);
         return true;
     };
+    /**
+     * Record (or, with `undefined`, forget) the integration layer's own
+     * attribution resolver for a provider. See `attributions`.
+     */
+    EvmProviderRegistry.prototype.rememberAttribution = function (provider, resolve) {
+        if (!provider)
+            return;
+        if (!resolve) {
+            this.attributions.delete(provider);
+            return;
+        }
+        this.attributions.set(provider, resolve);
+    };
+    /** The supplied attribution for a provider, if any resolves right now. */
+    EvmProviderRegistry.prototype.suppliedAttributionFor = function (provider) {
+        var resolve = this.attributions.get(provider);
+        if (!resolve)
+            return undefined;
+        try {
+            var info = resolve();
+            return (info === null || info === void 0 ? void 0 : info.name) ? info : undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
     /**
      * A provider's display name and rdns.
      *
-     * EIP-6963 metadata is authoritative when we have it; otherwise fall back to
-     * sniffing the injected provider, which is all a pre-6963 wallet offers.
+     * EIP-6963 metadata is authoritative when we have it. A supplied
+     * attribution (the connector a wagmi app connected through) comes next:
+     * it describes the SESSION, which is what the hook-driven events report.
+     * Otherwise fall back to sniffing the injected provider, which is all a
+     * pre-6963 wallet offers; a supplied name without an rdns keeps the
+     * sniffed rdns.
      */
     EvmProviderRegistry.prototype.infoFor = function (provider) {
         var announced = this.details.find(function (p) { return p.provider === provider; });
+        var supplied = announced
+            ? undefined
+            : this.suppliedAttributionFor(provider);
         var info = announced
             ? { name: announced.info.name, rdns: announced.info.rdns }
             : (function () {
+                var _a;
                 var injected = detectInjectedProviderInfo(provider);
-                return { name: injected.name, rdns: injected.rdns };
+                return supplied
+                    ? { name: supplied.name, rdns: (_a = supplied.rdns) !== null && _a !== void 0 ? _a : injected.rdns }
+                    : { name: injected.name, rdns: injected.rdns };
             })();
         // WalletConnect names the TRANSPORT; the session's peer names the
         // wallet. Resolved live, per read: a session established after the
@@ -154,7 +208,10 @@ var EvmProviderRegistry = /** @class */ (function () {
         // is included because a flagless WalletConnect-compatible provider
         // registered BEFORE its session exists detects as nothing at all;
         // the peer appearing later is itself the proof of what it was, so
-        // the rdns upgrades with it.
+        // the rdns upgrades with it. A supplied name gets the same treatment
+        // and no more: the integration layer resolves its own peer names
+        // where it wants them, and a branded connector must keep its name on
+        // both paths.
         if (info.name === "WalletConnect" || info.name === "Injected Provider") {
             var peer = readWalletConnectPeer(provider);
             if (peer === null || peer === void 0 ? void 0 : peer.name) {

package/dist/esm/src/evm/EvmRequestTracker.d.ts

@@ -83,10 +83,15 @@ export declare class EvmRequestTracker {
     /**
      * Wallet attribution for request-derived events.
      *
-     * Live per read through the registry, so a WalletConnect session names
-     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
-     * rows had provider_name EMPTY on every signature and transaction, which
-     * made per-wallet activity unanswerable in the warehouse.
+     * Resolved through the registry at the START of each request and held
+     * for that request's whole lifecycle, receipt included. Reading it per
+     * status let a connector switch (two connectors sharing one provider) or
+     * a session change made while a prompt was open split one operation
+     * between two wallet names. Still live across requests: a WalletConnect
+     * session names its actual signer ("MetaMask Wallet", "Ledger Live") -
+     * the live-test rows had provider_name EMPTY on every signature and
+     * transaction, which made per-wallet activity unanswerable in the
+     * warehouse.
      */
     private attributionFor;
     private buildSignatureEventPayload;

package/dist/esm/src/evm/EvmRequestTracker.js

@@ -296,7 +296,7 @@ var EvmRequestTracker = /** @class */ (function () {
      */
     EvmRequestTracker.prototype.dispatchWrappedRequest = function (_a, provider_1, request_1) {
         return __awaiter(this, arguments, void 0, function (_b, provider, request) {
-            var generation_1, responsePromise, capturedChainId_1, response_1, error_1, rpcError, txPromise, txChainId_1, transactionHash_1, error_2, rpcError;
+            var generation_1, responsePromise, capturedChainId_1, attribution_1, response_1, error_1, rpcError, txPromise, txChainId_1, attribution_2, transactionHash_1, error_2, rpcError;
             var _this = this;
             var _c, _d, _e, _f;
             var method = _b.method, params = _b.params;
@@ -339,6 +339,7 @@ var EvmRequestTracker = /** @class */ (function () {
                         // below is never reported as unhandled. The real handling is there.
                         responsePromise.catch(function () { return undefined; });
                         capturedChainId_1 = this.registry.resolveChainId(provider);
+                        attribution_1 = this.attributionFor(provider);
                         // Fire-and-forget tracking
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var e_1;
@@ -346,7 +347,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), attribution_1)];
                                     case 1:
                                         _a.sent();
                                         return [3 /*break*/, 3];
@@ -372,7 +373,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)), attribution_1)];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -397,7 +398,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), attribution_1)];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -436,6 +437,7 @@ var EvmRequestTracker = /** @class */ (function () {
                         txPromise = request({ method: method, params: params });
                         txPromise.catch(function () { return undefined; });
                         txChainId_1 = this.registry.resolveChainId(provider);
+                        attribution_2 = this.attributionFor(provider);
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var payload, e_4;
                             return __generator(this, function (_a) {
@@ -445,7 +447,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.STARTED }, payload), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.STARTED }, payload), attribution_2)];
                                     case 2:
                                         _a.sent();
                                         return [3 /*break*/, 4];
@@ -472,11 +474,11 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }), attribution_2)];
                                     case 2:
                                         _a.sent();
                                         // Start async polling for transaction receipt
-                                        this.pollTransactionReceipt(provider, transactionHash_1, payload);
+                                        this.pollTransactionReceipt(provider, transactionHash_1, payload, attribution_2);
                                         return [3 /*break*/, 4];
                                     case 3:
                                         e_5 = _a.sent();
@@ -501,7 +503,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                             return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                         case 1:
                                             payload = _a.sent();
-                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.REJECTED }, payload), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.REJECTED }, payload), attribution_2)];
                                         case 2:
                                             _a.sent();
                                             return [3 /*break*/, 4];
@@ -523,10 +525,15 @@ var EvmRequestTracker = /** @class */ (function () {
     /**
      * Wallet attribution for request-derived events.
      *
-     * Live per read through the registry, so a WalletConnect session names
-     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
-     * rows had provider_name EMPTY on every signature and transaction, which
-     * made per-wallet activity unanswerable in the warehouse.
+     * Resolved through the registry at the START of each request and held
+     * for that request's whole lifecycle, receipt included. Reading it per
+     * status let a connector switch (two connectors sharing one provider) or
+     * a session change made while a prompt was open split one operation
+     * between two wallet names. Still live across requests: a WalletConnect
+     * session names its actual signer ("MetaMask Wallet", "Ledger Live") -
+     * the live-test rows had provider_name EMPTY on every signature and
+     * transaction, which made per-wallet activity unanswerable in the
+     * warehouse.
      */
     EvmRequestTracker.prototype.attributionFor = function (provider) {
         var info = this.registry.infoFor(provider);
@@ -596,8 +603,11 @@ var EvmRequestTracker = /** @class */ (function () {
     /**
      * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
      */
-    EvmRequestTracker.prototype.pollTransactionReceipt = function (provider_1, transactionHash_2, payload_1) {
-        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, maxAttempts, intervalMs) {
+    EvmRequestTracker.prototype.pollTransactionReceipt = function (provider_1, transactionHash_2, payload_1, attribution_3) {
+        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, 
+        // Snapshot from the broadcast: a connector or session change during
+        // the poll window must not relabel the receipt.
+        attribution, maxAttempts, intervalMs) {
             var attempts, poll;
             var _this = this;
             if (maxAttempts === void 0) { maxAttempts = 10; }
@@ -626,7 +636,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     // status: 1 = success, 0 = reverted
                                     if (receipt.status === "0x1" || receipt.status === 1) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
+                                            .transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }), attribution)
                                             .catch(function (e) {
                                             return logger.error("Formo: Failed to track transaction confirmation", e);
                                         });
@@ -634,7 +644,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     }
                                     else if (receipt.status === "0x0" || receipt.status === 0) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
+                                            .transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }), attribution)
                                             .catch(function (e) {
                                             return logger.error("Formo: Failed to track transaction revert", e);
                                         });

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.