@formo/analytics 1.37.0 → 1.38.1

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

@@ -19,6 +19,17 @@ export interface IFormoAnalytics {
     page(category?: string, name?: string, properties?: IFormoEventProperties, context?: IFormoEventContext, callback?: (...args: unknown[]) => void): Promise<void>;
     reset(): void;
     cleanup(): void;
+    /**
+     * Track a constructed (non-injected) EIP-1193 provider, such as a
+     * WalletConnect or Ledger provider the app built itself. Returns true when
+     * the provider is tracked, false when refused (wagmi mode, EVM disabled,
+     * or not a valid provider).
+     */
+    registerProvider(provider: EIP1193Provider, info?: {
+        name?: string;
+        rdns?: string;
+        icon?: `data:image/${string}`;
+    }): boolean;
     detect(params: {
         rdns: string;
         providerName: string;
@@ -171,6 +182,18 @@ export interface ReferralOptions {
  * Allows the SDK to hook into Wagmi v2 wallet events instead of wrapping EIP-1193 providers
  */
 export interface WagmiOptions {
+    /**
+     * OPT-IN: fall back to the EIP-1193 request wrapper for wallet calls the
+     * wagmi caches cannot see - imperative viem calls
+     * (walletClient.sendTransaction, .signMessage, .writeContract, raw
+     * request) that create no mutation. The active connector's provider gets
+     * the same wrapper the SDK's default mode uses. Off by default: wagmi
+     * mode's baseline contract is observing wagmi state and caches without
+     * touching the signing transport, and enabling this is an explicit,
+     * auditable decision. Hook-driven calls are never double-counted (a
+     * pending wagmi mutation stands the wrapper down).
+     */
+    eip1193Fallback?: boolean;
     /**
      * Wagmi config instance from createConfig()
      * The SDK will subscribe to this config's state changes to track wallet events

package/dist/esm/src/types/provider.d.ts

@@ -20,6 +20,22 @@ export type WrappedRequestFunction = (<T>(args: RequestArguments) => Promise<T |
     [WRAPPED_REQUEST_SYMBOL]?: boolean;
 };
 export declare const WRAPPED_REQUEST_REF_SYMBOL: unique symbol;
+/**
+ * The SDK instance a provider's installed wrapper currently reports to.
+ *
+ * The wrapper survives an SDK rebuild (nothing restores `provider.request`),
+ * and its closure holds the instance that installed it - whose event queue
+ * is CLOSED after cleanup. Without this slot, a rebuilt instance saw
+ * "already wrapped", reported success, and every request-derived event
+ * silently died in the old instance's queue. The slot holds the LIST of
+ * instances that registered this provider, in registration order; the
+ * wrapper routes each call to the newest one still live. A list rather
+ * than a single ref for two reasons: with several live instances (multi
+ * write-key pages) a cleanup degrades to newest-live-wins instead of
+ * dead-instance-wins, and the list is attached at install time, so
+ * rebinding mutates it and works even on a provider frozen AFTER wrapping.
+ */
+export declare const WRAPPED_REQUEST_OWNER_SYMBOL: unique symbol;
 export interface WrappedEIP1193Provider extends EIP1193Provider {
     [WRAPPED_REQUEST_REF_SYMBOL]?: WrappedRequestFunction;
 }

package/dist/esm/src/types/provider.js

@@ -1,3 +1,19 @@
 export var WRAPPED_REQUEST_SYMBOL = Symbol("formoWrappedRequest");
 export var WRAPPED_REQUEST_REF_SYMBOL = Symbol("formoWrappedRequestRef");
+/**
+ * The SDK instance a provider's installed wrapper currently reports to.
+ *
+ * The wrapper survives an SDK rebuild (nothing restores `provider.request`),
+ * and its closure holds the instance that installed it - whose event queue
+ * is CLOSED after cleanup. Without this slot, a rebuilt instance saw
+ * "already wrapped", reported success, and every request-derived event
+ * silently died in the old instance's queue. The slot holds the LIST of
+ * instances that registered this provider, in registration order; the
+ * wrapper routes each call to the newest one still live. A list rather
+ * than a single ref for two reasons: with several live instances (multi
+ * write-key pages) a cleanup degrades to newest-live-wins instead of
+ * dead-instance-wins, and the list is attached at install time, so
+ * rebinding mutates it and works even on a provider frozen AFTER wrapping.
+ */
+export var WRAPPED_REQUEST_OWNER_SYMBOL = Symbol("formoWrappedRequestOwner");
 //# sourceMappingURL=provider.js.map

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

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

package/dist/esm/src/version.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-export var version = '1.37.0';
+export var version = '1.38.1';
 //# sourceMappingURL=version.js.map

package/dist/esm/src/wagmi/WagmiEventHandler.d.ts

@@ -204,6 +204,7 @@ export declare class WagmiEventHandler {
      * already recorded the new address synchronously by the time this runs. The
      * `lastAddress` check below is what makes the two paths mutually exclusive.
      */
+    private handleActiveAddressChangeEntryKick;
     private handleActiveAddressChange;
     /**
      * Record and emit a chain move for the wallet already being tracked.
@@ -266,6 +267,26 @@ export declare class WagmiEventHandler {
     /**
      * Handle signature mutations (signMessage, signTypedData)
      */
+    /**
+     * Is a PENDING wagmi mutation already covering this wallet request?
+     *
+     * The hybrid-capture dedup. TanStack dispatches `pending` BEFORE the
+     * mutationFn issues the wallet call (verified against query-core), so a
+     * hook-driven request always finds its mutation here and the request
+     * wrapper stands down; an imperative viem call never does, and the
+     * wrapper captures it. Matching is by mutation type, refined with cheap
+     * parameter checks where the shapes allow, and errs toward NOT skipping:
+     * a duplicate is visible and diagnosable, a silent loss is neither.
+     */
+    hasMatchingPendingMutation(method: string, params: unknown[]): boolean;
+    /**
+     * Wallet attribution for mutation- and query-derived events.
+     *
+     * Mid-session events (signatures, transactions) fire after the peer
+     * lookup has resolved, so a WalletConnect connector names its actual
+     * signer here - the first observable consumer of the peer cache.
+     */
+    private mutationAttribution;
     private handleSignatureMutation;
     /**
      * Handle transaction mutations (sendTransaction, writeContract)
@@ -320,6 +341,66 @@ export declare class WagmiEventHandler {
      * Get the connector name from Wagmi state
      */
     private getConnectorName;
+    /**
+     * Start resolving the wallet behind a WalletConnect connection.
+     *
+     * Fire-and-forget on purpose: emission paths are synchronous by design
+     * and must never wait (see the connect marker comment). Called at the
+     * START of the status/address flows rather than only at read time - the
+     * lookup is one microtask for an initialised connector, and the emission
+     * sits behind several awaits, so kicking early usually means even the
+     * FIRST connect names the real wallet. When the race is lost the event
+     * honestly says "WalletConnect" and every later event names the peer.
+     */
+    /**
+     * Install the request wrapper on the active connector's provider.
+     *
+     * This is what lets wagmi mode capture IMPERATIVE viem calls
+     * (walletClient.sendTransaction / .signMessage / .writeContract / raw
+     * request), which create no mutation and were silently lost. Hook-driven
+     * calls stay owned by the mutation handlers via the pending-mutation
+     * dedup. Fire-and-forget per connection; a provider that cannot be
+     * produced simply keeps mutation-only capture.
+     */
+    /**
+     * Connections THIS instance has wrapped. Deliberately per-instance, not
+     * module-level: a module-level guard let a rebuilt SDK instance skip
+     * re-wrapping, so ownership stayed with the torn-down instance and every
+     * capture died in its closed queue - and it also stopped a second
+     * write-key instance from ever registering. Re-wrapping is safe and
+     * cheap: the request tracker rebinds ownership of an intact wrapper.
+     */
+    /**
+     * Latest wrap attempt per connector. Every kick re-resolves
+     * getProvider() - a connector can hand out a REPLACEMENT provider after
+     * a reconnect, so a once-only guard would leave the new session's
+     * provider unwrapped forever. Re-wrapping is idempotent: the request
+     * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+     * resolution from a superseded kick (an earlier session, an earlier
+     * chain) be discarded instead of overwriting fresher state.
+     */
+    private wrapEpochs;
+    /** Consecutive automatic wrap retries per connector; see below. */
+    private wrapRetryCounts;
+    /** Pending retry timers, cancelled by cleanup(). */
+    private wrapRetryTimers;
+    /**
+     * Bumped on every observed disconnect. Every wrap attempt captures it
+     * at kick time and its resolution stands down on a mismatch, so a
+     * disconnect invalidates ALL pending wraps at once - including ones
+     * whose getProvider() had not resolved yet, which no per-connector
+     * bookkeeping can reach because nothing has been recorded for them.
+     */
+    private wrapSessionGeneration;
+    /** The active connector this instance wrapped, and its provider, for
+     * chain updates. Kept as a pair so a chain report is only ever applied
+     * to the provider of the connector it describes. Keyed by connector,
+     * not by connection record: wagmi REPLACES the connection object on
+     * every account or chain update, so record identity is not stable. */
+    private fallbackConnector?;
+    private fallbackProvider?;
+    private wrapActiveConnectorProvider;
+    private kickWalletConnectPeerLookup;
     /**
      * Clean up all subscriptions
      */