@formo/analytics 1.38.1 → 1.38.2

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/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.38.1";
+export declare const version = "1.38.2";
 //# 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.38.1';
+export var version = '1.38.2';
 //# sourceMappingURL=version.js.map

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

@@ -6,7 +6,7 @@
  * wrapping approach when Wagmi mode is enabled.
  */
 import { FormoAnalytics } from "../FormoAnalytics";
-import { WagmiConfig, QueryClient } from "./types";
+import { QueryClient, WagmiConfig } from "./types";
 /**
  * How long the markers stay trustworthy after the last handler goes away.
  *
@@ -337,6 +337,35 @@ export declare class WagmiEventHandler {
      * (still connected through its own connector).
      */
     private isAddressConnected;
+    /**
+     * A specific connector's name and rdns, for the fallback-wrapped
+     * provider's request-derived events.
+     *
+     * The NAME is exactly what the hook path emits for that connector
+     * (`getConnectorName`: the live WalletConnect peer for a WalletConnect
+     * connector, the connector's own name otherwise), so a branded connector
+     * keeps its name on both paths and a session that changes wallets
+     * renames on both. The rdns is the connector's when wagmi knows it as
+     * ONE value (EIP-6963 discovered connectors carry theirs, some as a
+     * one-element list); a connector that matches several rdns values does
+     * not say which one this provider is, so nothing is passed and the
+     * registry keeps the sniffed one.
+     */
+    private attributionForConnector;
+    /**
+     * Resolver handed to the registry at wrap time, read at each request
+     * start. BOUND to the connector whose `getProvider` resolved to the
+     * wrapped provider, not to whichever connector is current: an app can
+     * keep a wallet client over a previous connector's provider and issue a
+     * request through it after switching, and that request belongs to the
+     * wallet that handles it. The peer name is still read live. A provider
+     * SHARED by two connectors is re-bound when the new connector's
+     * resolution lands (one microtask for an injected connector); a request
+     * issued inside that gap keeps the previous label.
+     */
+    private boundConnectorAttribution;
+    /** `getConnectorName` for a SPECIFIC connector, current or not. */
+    private nameForConnector;
     /**
      * Get the connector name from Wagmi state
      */

package/dist/esm/src/wagmi/WagmiEventHandler.js

@@ -71,6 +71,16 @@ var RESERVED_FIELDS = new Set([
     "transactionHash",
     "function_name",
     "function_args",
+    // Wallet attribution. Function args are spread AFTER the attribution
+    // properties, so an ABI input named `providerName` would silently
+    // relabel the wallet on every broadcast and receipt event. `rdns` is
+    // reserved with it even though THIS path (wagmi mutation attribution)
+    // emits only the name: elsewhere in the SDK - the EIP-1193 request path
+    // and connect events - `rdns` is the wallet-identity key, so an ABI
+    // input by that name would land in the same warehouse column as real
+    // wallet identities.
+    "providerName",
+    "rdns",
 ]);
 /**
  * Connections already announced to a destination during this page load.
@@ -2333,6 +2343,75 @@ var WagmiEventHandler = /** @class */ (function () {
         });
         return found;
     };
+    /**
+     * A specific connector's name and rdns, for the fallback-wrapped
+     * provider's request-derived events.
+     *
+     * The NAME is exactly what the hook path emits for that connector
+     * (`getConnectorName`: the live WalletConnect peer for a WalletConnect
+     * connector, the connector's own name otherwise), so a branded connector
+     * keeps its name on both paths and a session that changes wallets
+     * renames on both. The rdns is the connector's when wagmi knows it as
+     * ONE value (EIP-6963 discovered connectors carry theirs, some as a
+     * one-element list); a connector that matches several rdns values does
+     * not say which one this provider is, so nothing is passed and the
+     * registry keeps the sniffed one.
+     */
+    WagmiEventHandler.prototype.attributionForConnector = function (connector, state) {
+        var name = this.nameForConnector(connector, state);
+        if (!name) {
+            return undefined;
+        }
+        var raw = connector.rdns;
+        var rdns = typeof raw === "string" && raw.length > 0
+            ? raw
+            : Array.isArray(raw) && raw.length === 1 && typeof raw[0] === "string" && raw[0].length > 0
+                ? raw[0]
+                : undefined;
+        return __assign({ name: name }, (rdns && { rdns: rdns }));
+    };
+    /**
+     * Resolver handed to the registry at wrap time, read at each request
+     * start. BOUND to the connector whose `getProvider` resolved to the
+     * wrapped provider, not to whichever connector is current: an app can
+     * keep a wallet client over a previous connector's provider and issue a
+     * request through it after switching, and that request belongs to the
+     * wallet that handles it. The peer name is still read live. A provider
+     * SHARED by two connectors is re-bound when the new connector's
+     * resolution lands (one microtask for an injected connector); a request
+     * issued inside that gap keeps the previous label.
+     */
+    WagmiEventHandler.prototype.boundConnectorAttribution = function (connector) {
+        var _this = this;
+        return function () {
+            if (_this.disposed)
+                return undefined;
+            try {
+                return _this.attributionForConnector(connector, _this.getState());
+            }
+            catch (_a) {
+                return undefined;
+            }
+        };
+    };
+    /** `getConnectorName` for a SPECIFIC connector, current or not. */
+    WagmiEventHandler.prototype.nameForConnector = function (connector, state) {
+        var _a;
+        var cached = walletConnectPeerNames.get(connector);
+        if (cached) {
+            return cached;
+        }
+        var current = state.current
+            ? (_a = state.connections.get(state.current)) === null || _a === void 0 ? void 0 : _a.connector
+            : undefined;
+        if (current === connector) {
+            // Backstop kick, as in getConnectorName; only the current connection
+            // has a session to look up.
+            this.kickWalletConnectPeerLookup(state);
+        }
+        var name = connector.name;
+        return typeof name === "string" && name.length > 0 ? name : undefined;
+    };
     /**
      * Get the connector name from Wagmi state
      */
@@ -2470,7 +2549,7 @@ var WagmiEventHandler = /** @class */ (function () {
                 return;
             }
             var chainId = (_b = _this.getActiveConnectionChainId(live)) !== null && _b !== void 0 ? _b : live.chainId;
-            var wrapped = (_d = (_c = _this.formo)._wrapWagmiProvider) === null || _d === void 0 ? void 0 : _d.call(_c, provider, typeof chainId === "number" ? chainId : undefined);
+            var wrapped = (_d = (_c = _this.formo)._wrapWagmiProvider) === null || _d === void 0 ? void 0 : _d.call(_c, provider, typeof chainId === "number" ? chainId : undefined, _this.boundConnectorAttribution(connector));
             if (wrapped !== true) {
                 // The provider was refused (invalid shape, frozen provider,
                 // torn-down SDK).

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

@@ -31,6 +31,12 @@ export interface WagmiConnector {
     name: string;
     type: string;
     uid: string;
+    /**
+     * Any connector implementation may expose an rdns; EIP-6963 discovered
+     * connectors are one source. A connector matching several rdns values
+     * lists them all.
+     */
+    rdns?: string | readonly string[];
 }
 /**
  * Wagmi config interface

package/dist/esm/src/wagmi/utils.js

@@ -185,7 +185,15 @@ export function buildSafeFunctionArgs(functionArgs, reservedFields) {
     var result = {};
     for (var _i = 0, _a = Object.entries(functionArgs); _i < _a.length; _i++) {
         var _b = _a[_i], key = _b[0], val = _b[1];
-        var safeKey = reservedFields.has(key) ? "arg_".concat(key) : key;
+        // A prefixed key must not land on another argument's own name: an ABI
+        // with both `to` and `arg_to` would otherwise keep only one of them,
+        // whichever came later. Keep prefixing until the name is free.
+        var safeKey = key;
+        if (reservedFields.has(key)) {
+            do {
+                safeKey = "arg_".concat(safeKey);
+            } while (safeKey in functionArgs);
+        }
         result[safeKey] = val;
         // If the value is a nested object (struct), flatten it
         // Skip flattened keys that would overwrite existing top-level args