@formo/analytics 1.37.0 → 1.38.1

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

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -35,6 +46,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvmEventTracker = void 0;
 var mipd_1 = require("mipd");
@@ -58,11 +78,71 @@ var PROVIDER_SWITCH_REASONS = {
  * deciding when a connect has to be reported, when a switch is stale, and
  * when a provider has stopped being the one we follow.
  */
+/**
+ * A registered provider's current accounts, from its synchronous state.
+ *
+ * `provider.accounts` first - but a LIVE MetaMask Mobile session over
+ * WalletConnect has been observed with `accounts` EMPTY while the session's
+ * namespaces held the approved account ("eip155:11155111:0xabc..."), which
+ * silently defeated adoption. The namespaces are the session's ground
+ * truth, so they are the fallback. Still purely synchronous property
+ * reads; nothing goes on the wallet transport.
+ */
+function readProviderAccounts(provider) {
+    var _a;
+    var direct = provider.accounts;
+    if (Array.isArray(direct) &&
+        direct.length > 0 &&
+        direct.every(function (a) { return typeof a === "string"; })) {
+        return direct;
+    }
+    var session = provider.session;
+    // eip155 ONLY: a session can also carry Solana or other namespaces, and
+    // feeding a non-EVM address into the EVM adoption path would make
+    // validation reject it and drop the whole adoption. A session can also
+    // authorize DIFFERENT accounts per chain, so entries for the provider's
+    // active chain come first - the adopted address should be the one this
+    // chain actually authorized.
+    var ns = (_a = session === null || session === void 0 ? void 0 : session.namespaces) === null || _a === void 0 ? void 0 : _a.eip155;
+    var chainId = provider.chainId;
+    var parsed = typeof chainId === "number"
+        ? chainId
+        : typeof chainId === "string"
+            ? (0, chain_1.parseChainId)(chainId)
+            : undefined;
+    var activePrefix = parsed ? "eip155:".concat(parsed, ":") : undefined;
+    var forChain = [];
+    var others = [];
+    if (Array.isArray(ns === null || ns === void 0 ? void 0 : ns.accounts)) {
+        for (var _i = 0, _b = ns.accounts; _i < _b.length; _i++) {
+            var entry = _b[_i];
+            if (typeof entry !== "string" || !entry.startsWith("eip155:"))
+                continue;
+            var address = entry.split(":")[2];
+            if (!address)
+                continue;
+            var bucket = activePrefix && entry.startsWith(activePrefix) ? forChain : others;
+            if (!bucket.includes(address))
+                bucket.push(address);
+        }
+    }
+    var out = __spreadArray(__spreadArray([], forChain, true), others.filter(function (a) { return !forChain.includes(a); }), true);
+    return out;
+}
 var EvmEventTracker = /** @class */ (function () {
     function EvmEventTracker(wallet, registry, deps) {
         this.wallet = wallet;
         this.registry = registry;
         this.deps = deps;
+        /**
+         * Providers adopted through `registerProvider` rather than discovered.
+         * Announcement-driven cleanup must not touch them: they are never in an
+         * announcement list, so "missing from the announcement" is their normal
+         * state, not evidence of removal. A Set rather than a WeakSet because
+         * suppressed adoptions retry from it; the registry holds these providers
+         * strongly anyway, and untrack removes them.
+         */
+        this.externallyRegistered = new Set();
         /**
          * The connect this SDK has already reported for a provider.
          *
@@ -190,6 +270,103 @@ var EvmEventTracker = /** @class */ (function () {
             logger_1.logger.error("Failed to track EIP-6963 providers during initialization:", error);
         }
     };
+    /**
+     * Adopt a provider the page constructed rather than announced.
+     *
+     * Discovery only ever sees EIP-6963 announcements and `window.ethereum`.
+     * A WalletConnect or Ledger provider is a constructed object that does
+     * neither, so without this entry point its whole session is invisible -
+     * the P-2403 gap. The pipeline from here on is the same one every
+     * discovered provider takes: registry, detect event, listeners, request
+     * wrapper.
+     *
+     * A session that already exists at registration is seeded from the
+     * provider's SYNCHRONOUS `accounts` state (WalletConnect exposes it), via
+     * the same accounts-arrival path a live `accountsChanged` takes. No RPC:
+     * nothing analytics-only may go on a wallet's transport, and
+     * WalletConnect's serialised relay socket is the very case that rule
+     * exists for.
+     */
+    EvmEventTracker.prototype.adoptExternalProvider = function (detail) {
+        var provider = detail.provider;
+        // Exempt from announcement-driven cleanup BEFORE tracking: a registered
+        // provider is never in an EIP-6963 announcement, so without this the
+        // next wallet announcement would untrack it and its events would stop.
+        this.externallyRegistered.add(provider);
+        this.registry.add(detail);
+        this.trackProviders([detail]);
+        // Adoption and success both hinge on the wrapper actually installing:
+        // reporting success for a provider whose requests stay invisible would
+        // recreate the silent loss this API exists to close.
+        if (!this.registry.isTracked(provider)) {
+            this.externallyRegistered.delete(provider);
+            // Tracking got partway: lifecycle listeners may already be attached
+            // even though the request wrapper failed. Leaving them would leak
+            // callbacks that hold this instance for the life of the page.
+            this.untrackProvider(provider);
+            logger_1.logger.warn("adoptExternalProvider: provider could not be tracked");
+            return false;
+        }
+        // A provider that was ALREADY tracked skips the pipeline above, and
+        // "tracked" means lifecycle listeners - it says nothing about the
+        // request wrapper, which a wallet can have replaced since. Re-verify
+        // it on every registration: the call reinstalls a displaced wrapper,
+        // rebinds ownership of an intact one, and refuses when it cannot -
+        // and success here must mean capture actually works.
+        if (!this.deps.registerRequestListeners(provider)) {
+            this.externallyRegistered.delete(provider);
+            this.untrackProvider(provider);
+            logger_1.logger.warn("adoptExternalProvider: request wrapper could not be ensured");
+            return false;
+        }
+        // Detect with the LIVE name (peer-resolved when a session exists);
+        // the stored metadata stays generic so later sessions rename freely.
+        void this.detectWallets([
+            __assign(__assign({}, detail), { info: __assign(__assign({}, detail.info), this.registry.infoFor(provider)) }),
+        ]);
+        var accounts = readProviderAccounts(provider);
+        if (accounts.length > 0) {
+            void this.onAccountsChanged(provider, accounts);
+        }
+        return true;
+    };
+    /**
+     * Re-run session adoption for every registered external provider.
+     *
+     * Registration while tracking was suppressed (opt-out, excluded route)
+     * reached the adoption path and was refused - and a provider whose
+     * session already exists may never emit another accountsChanged, so
+     * nothing would ever retry. Called when suppression can have ended
+     * (opt-in, page navigation). Idempotent: an already-adopted wallet is
+     * deduplicated by the same state and markers as any repeated signal.
+     */
+    EvmEventTracker.prototype.retryExternalAdoptions = function () {
+        var _this = this;
+        this.externallyRegistered.forEach(function (provider) {
+            // A flagless provider registered BEFORE pairing detected as the
+            // generic injected identity; once the session's peer exists, the
+            // live identity differs and the corrected detect fires. The
+            // session-scoped rdns dedup keeps this from repeating.
+            var live = _this.registry.infoFor(provider);
+            if (live.rdns === "com.walletconnect") {
+                void _this.detectWallets([
+                    {
+                        info: {
+                            name: live.name,
+                            rdns: live.rdns,
+                            uuid: "corrected-com-walletconnect",
+                            icon: provider_1.DEFAULT_PROVIDER_ICON,
+                        },
+                        provider: provider,
+                    },
+                ]);
+            }
+            var accounts = readProviderAccounts(provider);
+            if (accounts.length > 0) {
+                void _this.onAccountsChanged(provider, accounts);
+            }
+        });
+    };
     EvmEventTracker.prototype.registerAccountsChangedListener = function (provider) {
         var _this = this;
         logger_1.logger.info("registerAccountsChangedListener");
@@ -1004,6 +1181,11 @@ var EvmEventTracker = /** @class */ (function () {
         var currentProviderInstances = new Set(current.map(function (detail) { return detail.provider; }));
         for (var _i = 0, _a = this.registry.trackedProviders(); _i < _a.length; _i++) {
             var provider = _a[_i];
+            // A registered external provider is never announced over EIP-6963;
+            // its absence from an announcement list says nothing about it.
+            if (this.externallyRegistered.has(provider)) {
+                continue;
+            }
             if (!currentProviderInstances.has(provider)) {
                 logger_1.logger.info("Cleaning up unavailable provider: ".concat(provider.constructor.name));
                 this.untrackProvider(provider);

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

@@ -143,11 +143,33 @@ var EvmProviderRegistry = /** @class */ (function () {
      */
     EvmProviderRegistry.prototype.infoFor = function (provider) {
         var announced = this.details.find(function (p) { return p.provider === provider; });
-        if (announced) {
-            return { name: announced.info.name, rdns: announced.info.rdns };
+        var info = announced
+            ? { name: announced.info.name, rdns: announced.info.rdns }
+            : (function () {
+                var injected = (0, provider_1.detectInjectedProviderInfo)(provider);
+                return { 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
+        // provider was registered still gets its signer's name onto every
+        // event from then on. Only GENERIC names are replaced - a caller who
+        // registered an explicit display name keeps it. "Injected Provider"
+        // 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.
+        if (info.name === "WalletConnect" || info.name === "Injected Provider") {
+            var peer = (0, provider_1.readWalletConnectPeer)(provider);
+            if (peer === null || peer === void 0 ? void 0 : peer.name) {
+                return {
+                    name: peer.name,
+                    rdns: info.rdns === "io.injected.provider"
+                        ? "com.walletconnect"
+                        : info.rdns,
+                };
+            }
         }
-        var injected = (0, provider_1.detectInjectedProviderInfo)(provider);
-        return { name: injected.name, rdns: injected.rdns };
+        return info;
     };
     // ── listener bookkeeping ─────────────────────────────────────────────────
     EvmProviderRegistry.prototype.addListener = function (provider, event, listener) {

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

@@ -5,6 +5,13 @@ import { AutocaptureEventType } from "../tracking/TrackingPolicy";
 /** What the request tracker needs from the SDK that owns it. */
 export interface EvmRequestTrackerDeps {
     isAutocaptureEnabled(eventType: AutocaptureEventType): boolean;
+    /**
+     * Hybrid-capture dedup: true when a PENDING wagmi mutation already covers
+     * this request, so the mutation handler owns the capture. TanStack sets a
+     * mutation pending BEFORE its mutationFn issues the wallet call, so a
+     * hook-driven request always matches; an imperative one never does.
+     */
+    shouldSkipRequestCapture?(method: string, params: unknown[]): boolean;
     signature(params: {
         status: SignatureStatus;
         chainId?: ChainID;
@@ -23,16 +30,6 @@ export interface EvmRequestTrackerDeps {
         function_args?: Record<string, unknown>;
     }, properties?: IFormoEventProperties): Promise<void>;
 }
-/**
- * Autocapture for signatures and transactions, by wrapping a provider's
- * `request`.
- *
- * The wrapper is deliberately thin: it observes the call the dapp was already
- * making and never issues one of its own. That rule is why the chain a
- * request ran on is read from `eth_chainId` calls the app makes, rather than
- * probed - an SDK-issued lookup on a serialising transport can wedge the
- * user's wallet, which is never an acceptable price for a label.
- */
 export declare class EvmRequestTracker {
     private readonly wallet;
     private readonly registry;
@@ -50,6 +47,8 @@ export declare class EvmRequestTracker {
     constructor(wallet: WalletStateStore, registry: EvmProviderRegistry, deps: EvmRequestTrackerDeps);
     /** Stop every poll in flight. Terminal, like the event queue's close(). */
     cleanup(): void;
+    /** Providers whose owner list includes this instance; pruned on cleanup. */
+    private wrappedProviders;
     /** Re-arm a poll, unless this tracker has been torn down. */
     private schedulePoll;
     /**
@@ -58,7 +57,38 @@ export declare class EvmRequestTracker {
      * never retry it, and every signature and transaction from that wallet
      * would be missed for the rest of the session.
      */
+    /** Monotonic creation stamp; owner precedence is decided by it. */
+    private static nextCreationSeq;
+    readonly creationSeq: number;
+    /**
+     * Put this tracker into an owner list at its CREATION-ORDER position.
+     * Registration can arrive out of order - an older instance's async wrap
+     * kick may resolve after a newer instance's - and dispatch picks from
+     * the END of the list, so append-on-registration would let resolution
+     * order decide which instance owns capture. Creation order is what the
+     * newest-live contract promises.
+     */
+    private insertBySeniority;
     registerRequestListeners(provider: EIP1193Provider): boolean;
+    /** Install the wrapper function onto the provider; separated so the
+     * routing shim above stays small. */
+    private installWrappedRequest;
+    /**
+     * The wrapper body proper: everything a request observation does, run
+     * against THIS instance's registry, wallet state, and event queue. Kept
+     * as a method so a surviving wrapper installed by a previous SDK
+     * instance can hand calls to the current one.
+     */
+    private dispatchWrappedRequest;
+    /**
+     * 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.
+     */
+    private attributionFor;
     private buildSignatureEventPayload;
     private buildTransactionEventPayload;
     /**