@formo/analytics 1.35.2 → 1.36.0

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

@@ -0,0 +1,132 @@
+import { EIP6963ProviderDetail } from "mipd";
+import { Address, ChainID, EIP1193Provider, WrappedRequestFunction } from "../types";
+/** What the registry needs from the SDK that owns it. */
+export interface EvmProviderRegistryDeps {
+    /** The provider the SDK currently attributes activity to. */
+    activeProvider(): EIP1193Provider | undefined;
+    /** The active provider's chain, per central state. */
+    activeChainId(): ChainID | undefined;
+    /** The wallet already known for EVM, if any. */
+    knownEvmAddress(): Address | undefined;
+    /**
+     * A provider reported a chain.
+     *
+     * The registry records it per provider; whether central state should follow
+     * is the SDK's decision, not the registry's, because it depends on which
+     * namespace is active.
+     */
+    onChainObserved(provider: EIP1193Provider, chainId: number): void;
+}
+/**
+ * Which EVM wallets exist, and what is known about each.
+ *
+ * Split out of `FormoAnalytics` so "the provider registry" is one thing with
+ * one owner. It deliberately holds no event logic: registering listeners and
+ * reacting to them stays with the SDK for now, and moves next.
+ *
+ * Three provider sets, which are not the same thing:
+ *  - `details` is every EIP-6963 provider discovered, with its metadata.
+ *  - `tracked` is the subset that has listeners wired up.
+ *  - `seen` guards `details` against duplicates.
+ */
+export declare class EvmProviderRegistry {
+    private readonly deps;
+    private details;
+    private tracked;
+    private seen;
+    /** Last chain heard from each provider, whoever is active. */
+    private chainIds;
+    /**
+     * Bumped on every chain observation, PER PROVIDER, so a stale answer that
+     * arrives late cannot overwrite a newer one.
+     */
+    private chainGenerations;
+    /** Listeners this SDK attached, so teardown can remove exactly those. */
+    private listeners;
+    /** The window-injected provider, once detected, so it is not re-wrapped. */
+    private injectedDetail?;
+    constructor(deps: EvmProviderRegistryDeps);
+    get all(): readonly EIP6963ProviderDetail[];
+    isTracked(provider: EIP1193Provider): boolean;
+    markTracked(provider: EIP1193Provider): void;
+    forgetTracked(provider: EIP1193Provider): void;
+    trackedProviders(): EIP1193Provider[];
+    isSeen(provider: EIP1193Provider): boolean;
+    get injected(): EIP6963ProviderDetail | undefined;
+    set injected(detail: EIP6963ProviderDetail | undefined);
+    /** Counts for the public debug helpers. */
+    get counts(): {
+        totalProviders: number;
+        trackedProviders: number;
+        seenProviders: number;
+    };
+    /** Add a discovered provider once. Returns false if already present. */
+    add(detail: EIP6963ProviderDetail): boolean;
+    /**
+     * 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.
+     */
+    infoFor(provider: EIP1193Provider): {
+        name: string;
+        rdns: string;
+    };
+    addListener(provider: EIP1193Provider, event: string, listener: (...args: unknown[]) => void): void;
+    /** Remove only the listeners this SDK attached, never the host app's. */
+    removeListeners(provider: EIP1193Provider): void;
+    /** Events still attached to a provider after a failed teardown. */
+    attachedEvents(provider: EIP1193Provider): string[];
+    /**
+     * Whether this provider's `request` is already our wrapper.
+     *
+     * Checks the wrapper's own marker AND that the provider still points at
+     * that exact function, so a wallet that replaced `request` after we wrapped
+     * it is re-wrapped rather than left uninstrumented.
+     */
+    isWrapped(provider: EIP1193Provider, currentRequest: WrappedRequestFunction | undefined): boolean;
+    chainIdOf(provider: EIP1193Provider): number | undefined;
+    /** Advance and return this provider's chain-observation generation. */
+    bumpChainGeneration(provider: EIP1193Provider): number;
+    chainGeneration(provider: EIP1193Provider): number;
+    /**
+     * Record a provider's chain. Fed by `chainChanged` and `connect`, and by
+     * the one-off probe at tracking time, never from inside a user request.
+     */
+    rememberChain(provider: EIP1193Provider | undefined, chainId: number | undefined): void;
+    /**
+     * Resolve the chain an autocaptured request actually ran on.
+     *
+     * Central chain state is maintained by `chainChanged` from whichever
+     * provider is currently active. When a request arrives from a DIFFERENT
+     * tracked provider, which happens whenever a visitor has two wallets
+     * installed, that cached value describes the wrong wallet, and tagging the
+     * event with it silently mis-attributes the chain.
+     *
+     * Answered entirely from a per-provider snapshot. Deliberately SYNCHRONOUS
+     * and never issues an RPC.
+     *
+     * An earlier version called `eth_chainId` on the signing provider and
+     * time-boxed it with `Promise.race`. That is not safe: the race abandons
+     * the SDK's promise but cannot cancel the provider's request. On a
+     * transport that serialises (WalletConnect's relay socket, the very case
+     * this path exists to serve) an abandoned lookup stays at the head of the
+     * wallet's queue, and every later RPC the dapp makes queues behind it until
+     * reload. Mislabelling a chain is a reporting defect; wedging the user's
+     * wallet is not an acceptable way to avoid one.
+     *
+     * When nothing is known this reports 0 ("unknown") rather than guessing
+     * with the active provider's chain, which is known-wrong for another wallet.
+     */
+    resolveChainId(provider?: EIP1193Provider): number;
+    /**
+     * The wallet's first account, or null.
+     *
+     * Prefers what the SDK already knows, so an EVM context never returns a
+     * Solana address and no RPC is issued when the answer is already in hand.
+     */
+    addressOf(provider?: EIP1193Provider): Promise<Address | null>;
+    /** Every checksummed account a provider reports, or null. */
+    accountsOf(provider?: EIP1193Provider): Promise<Address[] | null>;
+}
+//# sourceMappingURL=EvmProviderRegistry.d.ts.map

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

@@ -0,0 +1,345 @@
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        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));
+};
+import { logger } from "../logger";
+import { validateAndChecksumAddress } from "../utils/address";
+import { detectInjectedProviderInfo } from "../provider";
+import { WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "../types";
+/**
+ * Which EVM wallets exist, and what is known about each.
+ *
+ * Split out of `FormoAnalytics` so "the provider registry" is one thing with
+ * one owner. It deliberately holds no event logic: registering listeners and
+ * reacting to them stays with the SDK for now, and moves next.
+ *
+ * Three provider sets, which are not the same thing:
+ *  - `details` is every EIP-6963 provider discovered, with its metadata.
+ *  - `tracked` is the subset that has listeners wired up.
+ *  - `seen` guards `details` against duplicates.
+ */
+var EvmProviderRegistry = /** @class */ (function () {
+    function EvmProviderRegistry(deps) {
+        this.deps = deps;
+        this.details = [];
+        this.tracked = new Set();
+        this.seen = new Set();
+        /** Last chain heard from each provider, whoever is active. */
+        this.chainIds = new WeakMap();
+        /**
+         * Bumped on every chain observation, PER PROVIDER, so a stale answer that
+         * arrives late cannot overwrite a newer one.
+         */
+        this.chainGenerations = new WeakMap();
+        /** Listeners this SDK attached, so teardown can remove exactly those. */
+        this.listeners = new Map();
+    }
+    Object.defineProperty(EvmProviderRegistry.prototype, "all", {
+        // ── the provider set ─────────────────────────────────────────────────────
+        get: function () {
+            return this.details;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EvmProviderRegistry.prototype.isTracked = function (provider) {
+        return this.tracked.has(provider);
+    };
+    EvmProviderRegistry.prototype.markTracked = function (provider) {
+        this.tracked.add(provider);
+    };
+    EvmProviderRegistry.prototype.forgetTracked = function (provider) {
+        this.tracked.delete(provider);
+    };
+    EvmProviderRegistry.prototype.trackedProviders = function () {
+        return Array.from(this.tracked);
+    };
+    EvmProviderRegistry.prototype.isSeen = function (provider) {
+        return this.seen.has(provider);
+    };
+    Object.defineProperty(EvmProviderRegistry.prototype, "injected", {
+        get: function () {
+            return this.injectedDetail;
+        },
+        set: function (detail) {
+            this.injectedDetail = detail;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EvmProviderRegistry.prototype, "counts", {
+        /** Counts for the public debug helpers. */
+        get: function () {
+            return {
+                totalProviders: this.details.length,
+                trackedProviders: this.tracked.size,
+                seenProviders: this.seen.size,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Add a discovered provider once. Returns false if already present. */
+    EvmProviderRegistry.prototype.add = function (detail) {
+        var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
+        if (!provider)
+            return false;
+        if (this.details.some(function (existing) { return existing.provider === provider; })) {
+            return false;
+        }
+        this.details = __spreadArray(__spreadArray([], this.details, true), [detail], false);
+        this.seen.add(provider);
+        return true;
+    };
+    /**
+     * 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.
+     */
+    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 injected = detectInjectedProviderInfo(provider);
+        return { name: injected.name, rdns: injected.rdns };
+    };
+    // ── listener bookkeeping ─────────────────────────────────────────────────
+    EvmProviderRegistry.prototype.addListener = function (provider, event, listener) {
+        var map = this.listeners.get(provider) || {};
+        map[event] = listener;
+        this.listeners.set(provider, map);
+    };
+    /** Remove only the listeners this SDK attached, never the host app's. */
+    EvmProviderRegistry.prototype.removeListeners = function (provider) {
+        var attached = this.listeners.get(provider);
+        if (!attached)
+            return;
+        // Keep whatever could not be removed. Forgetting a listener that is still
+        // attached loses the only reference to it, so nothing can ever try again:
+        // the callback stays live for the life of the page and holds the instance
+        // it closes over. A provider that throws transiently during teardown gets
+        // another chance on the next attempt.
+        var stillAttached = {};
+        for (var _i = 0, _a = Object.entries(attached); _i < _a.length; _i++) {
+            var _b = _a[_i], event_1 = _b[0], fn = _b[1];
+            try {
+                provider.removeListener(event_1, fn);
+            }
+            catch (e) {
+                logger.warn("Failed to remove listener for ".concat(String(event_1)), e);
+                stillAttached[event_1] = fn;
+            }
+        }
+        if (Object.keys(stillAttached).length > 0) {
+            this.listeners.set(provider, stillAttached);
+        }
+        else {
+            this.listeners.delete(provider);
+        }
+    };
+    /** Events still attached to a provider after a failed teardown. */
+    EvmProviderRegistry.prototype.attachedEvents = function (provider) {
+        var _a;
+        return Object.keys((_a = this.listeners.get(provider)) !== null && _a !== void 0 ? _a : {});
+    };
+    /**
+     * Whether this provider's `request` is already our wrapper.
+     *
+     * Checks the wrapper's own marker AND that the provider still points at
+     * that exact function, so a wallet that replaced `request` after we wrapped
+     * it is re-wrapped rather than left uninstrumented.
+     */
+    EvmProviderRegistry.prototype.isWrapped = function (provider, currentRequest) {
+        return !!(currentRequest &&
+            typeof currentRequest === "function" &&
+            currentRequest[WRAPPED_REQUEST_SYMBOL] &&
+            provider[WRAPPED_REQUEST_REF_SYMBOL] ===
+                currentRequest);
+    };
+    // ── per-provider chain knowledge ─────────────────────────────────────────
+    EvmProviderRegistry.prototype.chainIdOf = function (provider) {
+        return this.chainIds.get(provider);
+    };
+    /** Advance and return this provider's chain-observation generation. */
+    EvmProviderRegistry.prototype.bumpChainGeneration = function (provider) {
+        var _a;
+        var next = ((_a = this.chainGenerations.get(provider)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.chainGenerations.set(provider, next);
+        return next;
+    };
+    EvmProviderRegistry.prototype.chainGeneration = function (provider) {
+        var _a;
+        return (_a = this.chainGenerations.get(provider)) !== null && _a !== void 0 ? _a : 0;
+    };
+    /**
+     * Record a provider's chain. Fed by `chainChanged` and `connect`, and by
+     * the one-off probe at tracking time, never from inside a user request.
+     */
+    EvmProviderRegistry.prototype.rememberChain = function (provider, chainId) {
+        if (!provider || !chainId)
+            return;
+        // Any observation is newer than an `eth_chainId` still in flight for this
+        // provider.
+        this.bumpChainGeneration(provider);
+        this.chainIds.set(provider, chainId);
+        this.deps.onChainObserved(provider, chainId);
+    };
+    /**
+     * Resolve the chain an autocaptured request actually ran on.
+     *
+     * Central chain state is maintained by `chainChanged` from whichever
+     * provider is currently active. When a request arrives from a DIFFERENT
+     * tracked provider, which happens whenever a visitor has two wallets
+     * installed, that cached value describes the wrong wallet, and tagging the
+     * event with it silently mis-attributes the chain.
+     *
+     * Answered entirely from a per-provider snapshot. Deliberately SYNCHRONOUS
+     * and never issues an RPC.
+     *
+     * An earlier version called `eth_chainId` on the signing provider and
+     * time-boxed it with `Promise.race`. That is not safe: the race abandons
+     * the SDK's promise but cannot cancel the provider's request. On a
+     * transport that serialises (WalletConnect's relay socket, the very case
+     * this path exists to serve) an abandoned lookup stays at the head of the
+     * wallet's queue, and every later RPC the dapp makes queues behind it until
+     * reload. Mislabelling a chain is a reporting defect; wedging the user's
+     * wallet is not an acceptable way to avoid one.
+     *
+     * When nothing is known this reports 0 ("unknown") rather than guessing
+     * with the active provider's chain, which is known-wrong for another wallet.
+     */
+    EvmProviderRegistry.prototype.resolveChainId = function (provider) {
+        if (provider) {
+            var known = this.chainIds.get(provider);
+            if (known)
+                return known;
+            // Only the active provider's chain is described by central state.
+            var activeChain = this.deps.activeChainId();
+            if (provider === this.deps.activeProvider() && activeChain) {
+                return activeChain;
+            }
+            // A tracked provider we have never heard a chain from. Deliberately no
+            // fall back to central state: it belongs to a different wallet.
+            return 0;
+        }
+        return this.deps.activeChainId() || 0;
+    };
+    // ── reading accounts off a provider ──────────────────────────────────────
+    /**
+     * The wallet's first account, or null.
+     *
+     * Prefers what the SDK already knows, so an EVM context never returns a
+     * Solana address and no RPC is issued when the answer is already in hand.
+     */
+    EvmProviderRegistry.prototype.addressOf = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var active, p, known, accounts;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        active = this.deps.activeProvider();
+                        p = provider || active;
+                        // The cached wallet describes the ACTIVE provider, so it may only answer
+                        // for that one. Returning it for any provider reported the active wallet's
+                        // address under every other wallet's name and rdns, which is exactly what
+                        // `identify()` does when it scans the providers it has discovered.
+                        if (!provider || provider === active) {
+                            known = this.deps.knownEvmAddress();
+                            if (known)
+                                return [2 /*return*/, known];
+                        }
+                        if (!p) {
+                            logger.info("The provider is not set");
+                            return [2 /*return*/, null];
+                        }
+                        return [4 /*yield*/, this.accountsOf(p)];
+                    case 1:
+                        accounts = _a.sent();
+                        if (accounts && accounts.length > 0) {
+                            return [2 /*return*/, validateAndChecksumAddress(accounts[0]) || null];
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    /** Every checksummed account a provider reports, or null. */
+    EvmProviderRegistry.prototype.accountsOf = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var p, res, err_1, code;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        p = provider || this.deps.activeProvider();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, (p === null || p === void 0 ? void 0 : p.request({
+                                method: "eth_accounts",
+                            }))];
+                    case 2:
+                        res = _a.sent();
+                        if (!res || res.length === 0)
+                            return [2 /*return*/, null];
+                        return [2 /*return*/, res
+                                .map(function (e) { return validateAndChecksumAddress(e); })
+                                .filter(function (e) { return e !== undefined; })];
+                    case 3:
+                        err_1 = _a.sent();
+                        code = err_1 === null || err_1 === void 0 ? void 0 : err_1.code;
+                        if (code !== 4001) {
+                            logger.error("EvmProviderRegistry::accountsOf: eth_accounts threw an error", err_1);
+                        }
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return EvmProviderRegistry;
+}());
+export { EvmProviderRegistry };
+//# sourceMappingURL=EvmProviderRegistry.js.map

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

@@ -0,0 +1,120 @@
+import { Address, ChainID, EIP1193Provider, IFormoEventProperties, SignatureStatus, TransactionStatus } from "../types";
+import { WalletStateStore } from "../wallet/WalletStateStore";
+import { EvmProviderRegistry } from "./EvmProviderRegistry";
+import { AutocaptureEventType } from "../tracking/TrackingPolicy";
+/** What the request tracker needs from the SDK that owns it. */
+export interface EvmRequestTrackerDeps {
+    isAutocaptureEnabled(eventType: AutocaptureEventType): boolean;
+    signature(params: {
+        status: SignatureStatus;
+        chainId?: ChainID;
+        address: Address;
+        message: string;
+    }, properties?: IFormoEventProperties): Promise<void>;
+    transaction(params: {
+        status: TransactionStatus;
+        chainId: ChainID;
+        address: Address;
+        data?: string;
+        to?: string;
+        value?: string;
+        transactionHash?: string;
+        function_name?: string;
+        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;
+    private readonly deps;
+    /**
+     * Timers for receipt and batch-status polling.
+     *
+     * A poll re-arms for up to thirty seconds, so a torn-down instance would
+     * otherwise keep asking a wallet about transactions nobody is listening
+     * for, and hold the process open for the whole window. That is the same
+     * shape as the batch timer that hung the test suite in #338.
+     */
+    private polls;
+    private disposed;
+    constructor(wallet: WalletStateStore, registry: EvmProviderRegistry, deps: EvmRequestTrackerDeps);
+    /** Stop every poll in flight. Terminal, like the event queue's close(). */
+    cleanup(): void;
+    /** Re-arm a poll, unless this tracker has been torn down. */
+    private schedulePoll;
+    /**
+     * Wrap a provider's `request`. Returns whether the wrapper is installed:
+     * a caller that marks the provider as tracked on a false return would
+     * never retry it, and every signature and transaction from that wallet
+     * would be missed for the rest of the session.
+     */
+    registerRequestListeners(provider: EIP1193Provider): boolean;
+    private buildSignatureEventPayload;
+    private buildTransactionEventPayload;
+    /**
+     * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
+     */
+    private pollTransactionReceipt;
+    /**
+     * One `transaction` event per call in an EIP-5792 batch.
+     *
+     * A batch is not a transaction. It maps to several on-chain transactions,
+     * so reporting it as one event would understate volume and make revenue and
+     * per-contract attribution wrong for every app that adopts smart accounts.
+     * Each call is reported on its own, carrying the batch id so the calls can
+     * be reassembled downstream.
+     *
+     * Status is per BATCH, because that is what `wallet_getCallsStatus` reports.
+     * When it resolves, every call in the batch moves together, except where
+     * per-call receipts say otherwise on a non-atomic batch.
+     */
+    private trackBatchedCalls;
+    /**
+     * How one call in a settled batch ended.
+     *
+     * A per-call receipt is authoritative where it exists: that is what makes a
+     * partially reverted non-atomic batch report honestly rather than tarring
+     * every call with the batch's worst outcome. A receipt whose own status is
+     * unreadable falls back to the batch verdict rather than being assumed good.
+     *
+     * The codes are EIP-5792's: 200 confirmed, 400 failed BEFORE landing on
+     * chain, 500 reverted, 600 partially reverted. 400 is a rejection, not a
+     * revert - nothing was mined, so calling it reverted would misreport gas
+     * spent and on-chain activity that never happened.
+     *
+     * Returns undefined when the call cannot be decided, which happens on 600
+     * for a call the wallet gave no receipt for.
+     */
+    private batchCallOutcome;
+    /**
+     * The batch identifier from a `wallet_sendCalls` result.
+     *
+     * EIP-5792 settled on `{ id }`, but wallets shipped against the earlier
+     * draft return a bare string. Both are accepted so a wallet on either
+     * version is still grouped.
+     */
+    private readBatchId;
+    /**
+     * Resolve a batch through `wallet_getCallsStatus`.
+     *
+     * The status codes are EIP-5792's: 100 pending, 200 confirmed, 400 failed
+     * before landing, 500 reverted, 600 partially reverted. Anything below 200
+     * means keep waiting.
+     *
+     * A per-call receipt wins over the batch verdict where one exists, which is
+     * what makes a partially reverted non-atomic batch report honestly instead
+     * of marking every call with the batch's worst outcome.
+     */
+    private pollBatchStatus;
+}
+//# sourceMappingURL=EvmRequestTracker.d.ts.map