@metamask-previews/perps-controller 22.0.0-preview-896e0b6 → 22.0.0-preview-406090321

package/dist/providers/HyperLiquidProvider.js

@@ -791,9 +791,6 @@ export class HyperLiquidProvider {
     // Session cache for referral state (cleared on disconnect/reconnect)
     // Key: `network:userAddress`, Value: true if referral is set
     #referralCheckCache = new Map();
-    // Session-scoped, account/network-keyed support probes. Provider instances
-    // are discarded on reconnect; rejected probes are not retained.
-    #accountSupportByContext = new Map();
     // Session cache for builder fee approval state (cleared on disconnect/reconnect)
     // Key: `network:userAddress`, Value: true if builder fee is approved
     #builderFeeCheckCache = new Map();
@@ -1739,21 +1736,19 @@ export class HyperLiquidProvider {
      * multi-sig account with `ApiRequestError: Multi-sig required`, so the
      * unified-account migration must not be attempted for those accounts.
      *
-     * If the probe throws (transient network), returns `undefined` so callers
-     * can fail open without caching the transient result.
+     * If the probe throws (transient network), returns `false` — fail open so
+     * one bad probe never blocks migration for a normal single-signer account.
      * The `isHyperLiquidMultiSigRequiredError` fallback in the write's catch
      * block remains the safety net.
      *
      * @param userAddress - The wallet address to check.
      * @param infoClient - Optional captured reader for an operation-scoped probe.
-     * @returns True for multi-sig, false for single-signer, or undefined when
-     * the probe could not complete.
+     * @returns True only when Hyperliquid reports a multi-sig signer set.
      * @private
      */
-    async #isHyperliquidMultiSigAccount(userAddress, infoClient) {
+    async #isHyperliquidMultiSigAccount(userAddress, infoClient = this.#clientService.getInfoClient()) {
         try {
-            const reader = infoClient ?? this.#clientService.getInfoClient();
-            const signers = await reader.userToMultiSigSigners({
+            const signers = await infoClient.userToMultiSigSigners({
                 user: userAddress,
             });
             return signers !== null && signers !== undefined;
@@ -1763,165 +1758,8 @@ export class HyperLiquidProvider {
                 user: userAddress,
                 error: ensureError(error, 'HyperLiquidProvider.isHyperliquidMultiSigAccount').message,
             });
-            return undefined;
-        }
-    }
-    #getAccountSupportCacheKey(network, userAddress) {
-        return `${network}:${userAddress.toLowerCase()}`;
-    }
-    #recordAccountSupport(network, userAddress, support) {
-        this.#accountSupportByContext.set(this.#getAccountSupportCacheKey(network, userAddress), Promise.resolve(support));
-    }
-    /**
-     * Replace an optimistic support result after the venue authoritatively
-     * rejects a write from the account that supplied its signature.
-     *
-     * The captured context, rather than the currently selected account, owns the
-     * rejection because selection may change while the request is in flight.
-     *
-     * @param error - The failed write or mapped account-mode error.
-     * @param accountContext - Account and network that authorized the write.
-     * @returns Whether the rejection requires Hyperliquid multi-signature.
-     */
-    #recordUnsupportedAccountFromError(error, accountContext) {
-        const isMultiSigRequired = isHyperLiquidMultiSigRequiredError(error) ||
-            ensureError(error, 'HyperLiquidProvider.recordUnsupportedAccountFromError').message === PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED;
-        if (!isMultiSigRequired) {
             return false;
         }
-        this.#recordAccountSupport(accountContext.network, accountContext.userAddress, {
-            isSupported: false,
-            reason: 'multi_sig_account',
-        });
-        return true;
-    }
-    /**
-     * Correct support from errors returned as resolved per-entry statuses.
-     *
-     * @param statuses - Venue status entries.
-     * @param answer - Full venue answer that owns the statuses.
-     * @param accountContext - Account and network that authorized the write.
-     * @returns Whether any status requires Hyperliquid multi-signature.
-     */
-    #recordUnsupportedAccountFromStatuses(statuses, answer, accountContext) {
-        return statuses.some((status) => isStatusObject(status) &&
-            typeof status.error === 'string' &&
-            this.#recordUnsupportedAccountFromError(createStatusError(status.error, answer), accountContext));
-    }
-    /**
-     * Read support for an account context without initializing the provider.
-     * Successful results are stable for the provider session and coalesced by
-     * account and network. Failed probes fail open and remain retryable.
-     *
-     * @param context - An operation-scoped account context. Defaults to the
-     * currently active account and network.
-     * @returns Whether the account can submit Hyperliquid actions.
-     */
-    async #getAccountSupportForContext(context) {
-        const userAddress = context?.userAddress ??
-            (await this.#walletService.getUserAddressWithDefault());
-        const network = context?.network ??
-            (this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet');
-        const cacheKey = this.#getAccountSupportCacheKey(network, userAddress);
-        const cachedSupport = this.#accountSupportByContext.get(cacheKey);
-        if (cachedSupport) {
-            return cachedSupport;
-        }
-        const probe = this.#isHyperliquidMultiSigAccount(userAddress, context?.infoClient);
-        const support = probe.then((isMultiSig) => isMultiSig
-            ? { isSupported: false, reason: 'multi_sig_account' }
-            : { isSupported: true }, () => ({ isSupported: true }));
-        this.#accountSupportByContext.set(cacheKey, support);
-        probe
-            .then((isMultiSig) => {
-            if (isMultiSig === undefined &&
-                this.#accountSupportByContext.get(cacheKey) === support) {
-                this.#accountSupportByContext.delete(cacheKey);
-            }
-        }, () => {
-            if (this.#accountSupportByContext.get(cacheKey) === support) {
-                this.#accountSupportByContext.delete(cacheKey);
-            }
-        })
-            .catch(() => undefined);
-        return support;
-    }
-    async #assertAccountContextCurrent(context, operation) {
-        this.#assertProviderLifecycleCurrent(context.lifecycleGeneration, operation);
-        await this.#assertAccountIdentityCurrent(context);
-        this.#assertProviderLifecycleCurrent(context.lifecycleGeneration, operation);
-    }
-    /**
-     * Confirm that the selected address and network still match an action,
-     * without requiring the provider lifecycle that created it to remain active.
-     *
-     * @param context - The account and network captured by the action.
-     */
-    async #assertAccountIdentityCurrent(context) {
-        const currentAddress = await this.#walletService
-            .getUserAddressWithDefault()
-            .catch(() => undefined);
-        const currentNetwork = this.#clientService.isTestnetMode()
-            ? 'testnet'
-            : 'mainnet';
-        if (currentAddress?.toLowerCase() !== context.userAddress.toLowerCase() ||
-            currentNetwork !== context.network) {
-            throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
-        }
-    }
-    /**
-     * Permit best-effort rollback after teardown only while it still belongs to
-     * the same address and network, and the account is not known unsupported.
-     *
-     * @param context - The account and network captured by the parent action.
-     */
-    async #assertRollbackAccountWritable(context) {
-        await this.#assertAccountIdentityCurrent(context);
-        const cachedSupport = this.#accountSupportByContext.get(this.#getAccountSupportCacheKey(context.network, context.userAddress));
-        const support = cachedSupport ? await cachedSupport : undefined;
-        await this.#assertAccountIdentityCurrent(context);
-        if (support && !support.isSupported) {
-            throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
-        }
-    }
-    /**
-     * Block an action when another step has authoritatively corrected support
-     * for its captured account. A missing cache entry remains fail-open: this
-     * fence must not turn a transient probe failure into another network probe.
-     *
-     * @param context - The account, network, and lifecycle captured by the action.
-     * @param operation - Operation name included in lifecycle diagnostics.
-     */
-    async #assertNoKnownUnsupportedAccount(context, operation) {
-        await this.#assertAccountContextCurrent(context, operation);
-        const cachedSupport = this.#accountSupportByContext.get(this.#getAccountSupportCacheKey(context.network, context.userAddress));
-        const support = cachedSupport ? await cachedSupport : undefined;
-        await this.#assertAccountContextCurrent(context, operation);
-        if (support && !support.isSupported) {
-            throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
-        }
-    }
-    /**
-     * Stop an action before signing when Hyperliquid reports a native multi-sig
-     * signer set for the active account.
-     *
-     * @param expectedContext - Existing operation context to validate, or omit
-     * to capture the currently selected account and network.
-     * @returns The account context whose support was checked.
-     */
-    async #assertAccountSupported(expectedContext) {
-        const context = expectedContext ??
-            {
-                lifecycleGeneration: this.#lifecycleGeneration,
-                network: this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet',
-                userAddress: await this.#walletService.getUserAddressWithDefault(),
-            };
-        const support = await this.#getAccountSupportForContext(context);
-        await this.#assertAccountContextCurrent(context, 'Account support check');
-        if (!support.isSupported) {
-            throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
-        }
-        return context;
     }
     /**
      * Attempt to enable HyperLiquid Unified Account mode for HIP-3 orders
@@ -1934,8 +1772,6 @@ export class HyperLiquidProvider {
      *
      * @param options - Optional configuration.
      * @param options.allowUserSigning - When true, runs the migration for `default` / `disabled` accounts. Defaults to false so init does not surface a signing prompt; action-time entry points (trading, withdraw) pass true.
-     * @param options.accountContext - Account/network/lifecycle captured by the
-     * action that is allowed to authorize the migration.
      * @private
      */
     async #ensureUnifiedAccountEnabled(options) {
@@ -1954,11 +1790,8 @@ export class HyperLiquidProvider {
         if (!this.#useUnifiedAccount) {
             return; // Feature disabled
         }
-        const { accountContext } = options ?? {};
-        const userAddress = accountContext?.userAddress ??
-            (await this.#walletService.getUserAddressWithDefault());
-        const network = accountContext?.network ??
-            (this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet');
+        const userAddress = await this.#walletService.getUserAddressWithDefault();
+        const network = this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet';
         // Check global cache first to avoid repeated signing requests
         // This is CRITICAL for hardware wallets to prevent repeated signing prompts
         // while browsing.
@@ -2026,9 +1859,6 @@ export class HyperLiquidProvider {
             currentMode = await infoClient.userAbstraction({
                 user: userAddress,
             });
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Unified account mode lookup');
-            }
             if (currentMode === 'unifiedAccount' ||
                 currentMode === 'portfolioMargin') {
                 // portfolioMargin is a superset of unifiedAccount — it already supports
@@ -2072,21 +1902,17 @@ export class HyperLiquidProvider {
             // surfaced on the Perps tab on every entry (TAT-3214). Probe right
             // before the write so accounts that never reach one (already compatible,
             // deferred, unknown mode) do not pay the extra round trip.
-            const accountSupport = await this.#getAccountSupportForContext({
-                userAddress,
-                network,
-                infoClient,
-            });
-            if (!accountSupport.isSupported) {
+            const isMultiSig = await this.#isHyperliquidMultiSigAccount(userAddress);
+            if (isMultiSig) {
                 this.#deps.debugLogger.log('[ensureUnifiedAccountEnabled] Multi-sig account, skipping unified account migration', { user: userAddress, network, mode: currentMode });
                 this.#deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.AccountSetup, {
                     [PERPS_EVENT_PROPERTY.PREVIOUS_ABSTRACTION_MODE]: currentMode,
                     [PERPS_EVENT_PROPERTY.STATUS]: PERPS_EVENT_VALUE.STATUS.NOT_APPLICABLE,
                     [PERPS_EVENT_PROPERTY.ERROR_MESSAGE]: 'multi_sig_account',
                 });
-                // Final state: the migration can never succeed for this account, so
-                // cache it as attempted with unified mode off. Action readiness blocks
-                // this account before any later exchange write.
+                // Final state: the write can never succeed for this account, so cache
+                // it as attempted with unified mode off. Perps keeps working through
+                // the programmatic collateral-transfer fallback.
                 TradingReadinessCache.set(network, userAddress, {
                     attempted: true,
                     enabled: false,
@@ -2107,13 +1933,7 @@ export class HyperLiquidProvider {
                 previousMode: currentMode,
                 note: 'HyperLiquid will auto-manage collateral for HIP-3 orders',
             });
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Unified account migration');
-            }
-            const exchangeClient = this.#clientService.getExchangeClient(accountContext
-                ? async () => await this.#assertNoKnownUnsupportedAccount(accountContext, 'Unified account migration dispatch')
-                : undefined);
-            await exchangeClient.agentSetAbstraction({
+            await this.#clientService.getExchangeClient().agentSetAbstraction({
                 abstraction: HL_ABSTRACTION_WIRE.unifiedAccount,
             });
             this.#deps.debugLogger.log('✅ HyperLiquidProvider: Unified Account enabled successfully');
@@ -2168,10 +1988,6 @@ export class HyperLiquidProvider {
             // account-shape condition, not a failure worth reporting or retrying.
             if (isHyperLiquidMultiSigRequiredError(error)) {
                 this.#deps.debugLogger.log('[ensureUnifiedAccountEnabled] Multi-sig account (race/probe fallback), skipping unified account migration', { user: userAddress, network, mode: currentMode });
-                this.#recordAccountSupport(network, userAddress, {
-                    isSupported: false,
-                    reason: 'multi_sig_account',
-                });
                 this.#deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.AccountSetup, {
                     ...(currentMode && {
                         [PERPS_EVENT_PROPERTY.PREVIOUS_ABSTRACTION_MODE]: currentMode,
@@ -2204,12 +2020,6 @@ export class HyperLiquidProvider {
                 completeInFlight();
                 return;
             }
-            if (accountContext &&
-                ensureError(error, 'HyperLiquidProvider.ensureUnifiedAccountEnabled')
-                    .message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
-                completeInFlight();
-                throw error;
-            }
             // Agent-path failures and read-only userAbstraction lookup failures
             // are not final: signal #ensureReady to drop its memoized promise and
             // retry on the next entry instead of pinning the user in the
@@ -2278,26 +2088,10 @@ export class HyperLiquidProvider {
             // over. The memoized promise is dropped while the cooldown is active
             // (see below), so a later entry retries. Action-time callers are not
             // gated.
-            if (!this.#isDisconnected &&
-                Date.now() >= this.#unifiedAccountTransportRetryAt) {
-                if (this.#walletService.requiresSignatureConfirmation()) {
-                    await this.#ensureUnifiedAccountEnabled({
-                        allowUserSigning: false,
-                    });
-                }
-                else {
-                    const accountContext = {
-                        lifecycleGeneration: this.#lifecycleGeneration,
-                        network: this.#clientService.isTestnetMode()
-                            ? 'testnet'
-                            : 'mainnet',
-                        userAddress: await this.#walletService.getUserAddressWithDefault(),
-                    };
-                    await this.#ensureUnifiedAccountEnabled({
-                        allowUserSigning: true,
-                        accountContext,
-                    });
-                }
+            if (Date.now() >= this.#unifiedAccountTransportRetryAt) {
+                await this.#ensureUnifiedAccountEnabled({
+                    allowUserSigning: !this.#walletService.requiresSignatureConfirmation(),
+                });
             }
         })();
         // Await initialization - keep the promise so subsequent calls resolve immediately
@@ -2375,17 +2169,13 @@ export class HyperLiquidProvider {
      * code (the approval is otherwise non-blocking).
      * @param options.reportRefusal - Throw the venue's refusal, even without an
      * approval failure code.
-     * @param accountContext - Account/network/lifecycle captured by the action
-     * that is allowed to authorize this approval.
      * @returns The account, network, and configured builder for the action.
      */
-    async #ensureBuilderFeeSetup(approvalFailureCode, options = {}, accountContext) {
-        const lifecycleGeneration = accountContext?.lifecycleGeneration ?? this.#lifecycleGeneration;
-        const network = accountContext?.network ??
-            (this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet');
-        const isTestnet = network === 'testnet';
-        const userAddress = accountContext?.userAddress ??
-            (await this.#walletService.getUserAddressWithDefault());
+    async #ensureBuilderFeeSetup(approvalFailureCode, options = {}) {
+        const lifecycleGeneration = this.#lifecycleGeneration;
+        const isTestnet = this.#clientService.isTestnetMode();
+        const network = isTestnet ? 'testnet' : 'mainnet';
+        const userAddress = await this.#walletService.getUserAddressWithDefault();
         const cacheKey = this.#getCacheKey(network, userAddress);
         const builderAddress = this.#getBuilderAddress(isTestnet);
         const context = {
@@ -2413,7 +2203,7 @@ export class HyperLiquidProvider {
         }
         let pendingApproval = this.#builderFeeSetupPromises.get(setupKey);
         if (!pendingApproval) {
-            pendingApproval = this.#ensureBuilderFeeApproval(context, accountContext);
+            pendingApproval = this.#ensureBuilderFeeApproval(context);
             this.#builderFeeSetupPromises.set(setupKey, pendingApproval);
         }
         try {
@@ -2421,10 +2211,6 @@ export class HyperLiquidProvider {
         }
         catch (error) {
             this.#deps.debugLogger.log('[ensureBuilderFeeSetup] Builder fee approval failed', error);
-            if (accountContext &&
-                this.#recordUnsupportedAccountFromError(error, accountContext)) {
-                throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
-            }
             // A signer that could not sign is retryable, not an approval failure.
             if (approvalFailureCode || options.reportSignerFailure) {
                 const signerFailure = await this.#classifySignerFailure(error);
@@ -2457,15 +2243,10 @@ export class HyperLiquidProvider {
     async #ensureReadyForTrading(options) {
         // First ensure basic initialization is complete
         await this.#ensureReady();
-        const accountContext = await this.#assertAccountSupported(options.accountContext);
         // The migration was deferred during init to avoid a signing prompt on
         // Perps section open. Drive it here, gated by its own cache so
         // already-migrated users are not re-prompted.
-        await this.#ensureUnifiedAccountEnabled({
-            allowUserSigning: true,
-            accountContext,
-        });
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'Trading setup');
+        await this.#ensureUnifiedAccountEnabled({ allowUserSigning: true });
         // Reset right before the check, with no await in between, so a failure
         // above does not leave the setup for an order to run.
         if (options.recheckPendingReferral && this.#referralAwaitsBuilderCode) {
@@ -2487,7 +2268,7 @@ export class HyperLiquidProvider {
                     }
                 }
                 // Set up referral code independently from builder-fee applicability.
-                await this.#ensureReferralSet(accountContext);
+                await this.#ensureReferralSet();
                 this.#assertProviderLifecycleCurrent(lifecycleGeneration, 'Trading setup completion');
                 // Only mark complete if the main-account signer is ready (signing
                 // could actually happen) and the referral does not need another
@@ -2510,14 +2291,10 @@ export class HyperLiquidProvider {
             }
         }
         const builderFeeSetupContext = options.requiresBuilderFee
-            ? await this.#ensureBuilderFeeSetup(options.builderFeeApprovalFailureCode, {}, accountContext)
+            ? await this.#ensureBuilderFeeSetup(options.builderFeeApprovalFailureCode)
             : undefined;
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'Trading setup');
         this.#deps.debugLogger.log('[ensureReadyForTrading] Trading setup complete');
-        return {
-            accountContext,
-            ...(builderFeeSetupContext && { builderFeeSetupContext }),
-        };
+        return builderFeeSetupContext;
     }
     /**
      * Get current price for a symbol using WebSocket cache first, REST API fallback
@@ -3451,14 +3228,10 @@ export class HyperLiquidProvider {
      *
      * @param message - The status entry's error.
      * @param answer - The venue answer with the entry.
-     * @param accountContext - Account and network that authorized the write.
      * @returns The mapped error.
      */
-    async #mapStatusError(message, answer, accountContext) {
+    async #mapStatusError(message, answer) {
         const error = createStatusError(message, answer);
-        if (accountContext) {
-            this.#recordUnsupportedAccountFromError(error, accountContext);
-        }
         return (await this.#classifySignerFailure(error)) ?? this.#mapError(error);
     }
     /**
@@ -3587,17 +3360,10 @@ export class HyperLiquidProvider {
      * @param params.network - HyperLiquid network for the approval.
      * @param params.userAddress - Account that owns the approval.
      * @param params.builderAddress - Builder address being approved.
-     * @param accountContext - Account/network/lifecycle captured by the action
-     * that is allowed to authorize this approval.
      */
-    async #ensureBuilderFeeApproval(params, accountContext) {
-        const lifecycleGeneration = accountContext?.lifecycleGeneration ?? this.#lifecycleGeneration;
+    async #ensureBuilderFeeApproval(params) {
+        const lifecycleGeneration = this.#lifecycleGeneration;
         const { network, userAddress, builderAddress } = params;
-        const supportContext = accountContext ?? {
-            lifecycleGeneration,
-            network,
-            userAddress,
-        };
         this.#assertProviderLifecycleCurrent(lifecycleGeneration, 'Builder fee approval');
         const cacheKey = this.#getCacheKey(network, userAddress);
         // Check GLOBAL cache first to avoid repeated signing requests across reconnections
@@ -3635,12 +3401,7 @@ export class HyperLiquidProvider {
                 return;
             }
             const { isApproved, requiredDecimal } = await this.#checkBuilderFeeStatus(builderAddress, userAddress);
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Builder fee approval lookup');
-            }
-            else {
-                this.#assertProviderLifecycleCurrent(lifecycleGeneration, 'Builder fee approval');
-            }
+            this.#assertProviderLifecycleCurrent(lifecycleGeneration, 'Builder fee approval');
             if (isApproved) {
                 // User already has approval on-chain
                 PerpsSigningCache.setBuilderFee(network, userAddress, {
@@ -3653,20 +3414,12 @@ export class HyperLiquidProvider {
             }
             else {
                 this.#deps.debugLogger.log('[ensureBuilderFeeApproval] Approval required (will show signing request)', { builder: builderAddress, requiredDecimal });
-                if (accountContext) {
-                    await this.#assertNoKnownUnsupportedAccount(accountContext, 'Builder fee approval');
-                }
                 const exchangeClient = this.#clientService.getExchangeClient();
                 const maxFeeRate = BUILDER_FEE_CONFIG.MaxFeeRate;
-                const approvalResult = await exchangeClient.approveBuilderFee({
+                await exchangeClient.approveBuilderFee({
                     builder: builderAddress,
                     maxFeeRate,
                 });
-                if (approvalResult.status !== 'ok') {
-                    const approvalError = new Error(`Builder fee approval failed: ${JSON.stringify(approvalResult)}`);
-                    this.#recordUnsupportedAccountFromError(approvalError, supportContext);
-                    throw approvalError;
-                }
                 // Verify approval was successful before caching
                 const afterApprovalDecimal = await this.#checkBuilderFeeApproval(builderAddress, userAddress);
                 if (afterApprovalDecimal === null ||
@@ -3692,7 +3445,6 @@ export class HyperLiquidProvider {
             completeInFlight();
         }
         catch (error) {
-            this.#recordUnsupportedAccountFromError(error, supportContext);
             if (ensureError(error, 'HyperLiquidProvider.ensureBuilderFeeApproval')
                 .message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
                 completeInFlight();
@@ -3889,13 +3641,11 @@ export class HyperLiquidProvider {
      * @param params - Transfer parameters
      * @param params.targetDex - HIP-3 DEX name (e.g., 'xyz')
      * @param params.requiredMargin - Required margin with buffer
-     * @param params.accountContext - Account/network/lifecycle captured by the
-     * order that may authorize a transfer.
      * @returns Transfer info for rollback, or null if no transfer needed
      * @private
      */
     async #autoTransferForHip3Order(params) {
-        const { targetDex, requiredMargin, accountContext } = params;
+        const { targetDex, requiredMargin } = params;
         // Check target DEX balance
         const targetBalance = await this.#getBalanceForDex({ dex: targetDex });
         this.#deps.debugLogger.log('HyperLiquidProvider: HIP-3 balance check', {
@@ -3924,19 +3674,15 @@ export class HyperLiquidProvider {
             to: targetDex,
             amount: transferAmount,
         });
-        const transferParams = {
+        const result = await this.transferBetweenDexs({
             sourceDex: source.sourceDex,
             destinationDex: targetDex,
             amount: transferAmount,
-        };
-        const result = accountContext
-            ? await this.#transferBetweenDexsForContext(transferParams, accountContext)
-            : await this.transferBetweenDexs(transferParams);
+        });
         if (!result.success) {
-            // Preserve stable account/signer outcomes that callers handle directly.
-            if (result.error === PERPS_ERROR_CODES.KEYRING_LOCKED ||
-                result.error === PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED) {
-                throw new Error(result.error);
+            // The signer could not sign the transfer: retryable, not a defect.
+            if (result.error === PERPS_ERROR_CODES.KEYRING_LOCKED) {
+                throw new Error(PERPS_ERROR_CODES.KEYRING_LOCKED);
             }
             throw new Error(`Auto-transfer failed: ${result.error ?? 'Unknown error'}`);
         }
@@ -3964,13 +3710,11 @@ export class HyperLiquidProvider {
      * @param params.freedMargin - Amount of margin released from position close
      * @param params.transferAll - (Future) Transfer all available balance instead
      * @param params.skipTransfer - (Future) Skip auto-transfer if disabled
-     * @param params.accountContext - Original action context to preserve across
-     * the balance read and transfer.
      * @returns Transfer info if successful, null if skipped/failed
      * @private
      */
     async #autoTransferBackAfterClose(params) {
-        const { sourceDex, freedMargin, transferAll = false, skipTransfer = false, accountContext, } = params;
+        const { sourceDex, freedMargin, transferAll = false, skipTransfer = false, } = params;
         // Future: Check user preference to skip auto-transfer
         if (skipTransfer) {
             this.#deps.debugLogger.log('Auto-transfer back skipped (disabled by config)');
@@ -4006,14 +3750,11 @@ export class HyperLiquidProvider {
                 to: 'main',
             });
             // Execute transfer back to main DEX (empty string '' represents main DEX)
-            const transferParams = {
+            const result = await this.transferBetweenDexs({
                 sourceDex,
                 destinationDex: '',
                 amount: transferAmount.toFixed(USDC_DECIMALS),
-            };
-            const result = accountContext
-                ? await this.#transferBetweenDexsForContext(transferParams, accountContext)
-                : await this.transferBetweenDexs(transferParams);
+            });
             if (!result.success) {
                 this.#deps.debugLogger.log('❌ Auto-transfer back failed', {
                     error: result.error,
@@ -4137,12 +3878,11 @@ export class HyperLiquidProvider {
      * @param params.transferInfo - The transfer information.
      * @param params.transferInfo.amount - The amount value.
      * @param params.transferInfo.sourceDex - The source DEX for the transfer.
-     * @param params.accountContext - Original action context for any rebalance.
      * @returns Whether the balance check and any required transfer succeeded.
      * @private
      */
     async #handleHip3PostOrderRebalance(params) {
-        const { accountContext, dexName, transferInfo } = params;
+        const { dexName, transferInfo } = params;
         try {
             const postOrderBalance = await this.#getBalanceForDex({ dex: dexName });
             const transferredAmount = transferInfo.amount;
@@ -4167,11 +3907,11 @@ export class HyperLiquidProvider {
                         excessAmount: excessAmount.toFixed(2),
                         destinationDex: transferInfo.sourceDex,
                     });
-                    const transferResult = await this.#transferBetweenDexsForContext({
+                    const transferResult = await this.transferBetweenDexs({
                         sourceDex: dexName,
                         destinationDex: transferInfo.sourceDex,
                         amount: excessAmount.toFixed(USDC_DECIMALS),
-                    }, accountContext);
+                    });
                     if (!transferResult.success) {
                         // The signer could not sign the transfer: retryable, not a defect.
                         if (transferResult.error === PERPS_ERROR_CODES.KEYRING_LOCKED) {
@@ -4231,11 +3971,10 @@ export class HyperLiquidProvider {
      * @param params.transferInfo - The transfer information.
      * @param params.transferInfo.amount - The amount value.
      * @param params.transferInfo.sourceDex - The source DEX for the transfer.
-     * @param params.accountContext - Original action context for the rollback.
      * @private
      */
     async #handleHip3OrderRollback(params) {
-        const { accountContext, dexName, transferInfo } = params;
+        const { dexName, transferInfo } = params;
         try {
             this.#deps.debugLogger.log('HyperLiquidProvider: Rolling back failed order transfer', {
                 from: dexName,
@@ -4243,11 +3982,11 @@ export class HyperLiquidProvider {
                 amount: transferInfo.amount.toFixed(USDC_DECIMALS),
                 reason: 'order_failed',
             });
-            const rollbackResult = await this.#transferBetweenDexsForContext({
+            const rollbackResult = await this.transferBetweenDexs({
                 sourceDex: dexName, // From HIP-3 DEX
                 destinationDex: transferInfo.sourceDex, // Back to source
                 amount: transferInfo.amount.toFixed(USDC_DECIMALS),
-            }, accountContext);
+            });
             if (rollbackResult.success) {
                 this.#deps.debugLogger.log('✅ HyperLiquidProvider: Rollback successful', {
                     amount: transferInfo.amount.toFixed(USDC_DECIMALS),
@@ -4421,7 +4160,7 @@ export class HyperLiquidProvider {
      * @param params - The operation parameters.
      */
     async #prepareAssetForTrading(params) {
-        const { symbol, assetId, leverage, accountContext } = params;
+        const { symbol, assetId, leverage } = params;
         if (!leverage) {
             return;
         }
@@ -4432,21 +4171,14 @@ export class HyperLiquidProvider {
             requestedLeverage: leverage,
             leverageType: marginMode,
         });
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'Leverage update');
-        try {
-            const exchangeClient = this.#clientService.getExchangeClient();
-            const leverageResult = await exchangeClient.updateLeverage({
-                asset: assetId,
-                isCross: marginMode === 'cross',
-                leverage,
-            });
-            if (leverageResult.status !== 'ok') {
-                throw new Error(`Failed to update leverage: ${JSON.stringify(leverageResult)}`);
-            }
-        }
-        catch (error) {
-            this.#recordUnsupportedAccountFromError(error, accountContext);
-            throw error;
+        const exchangeClient = this.#clientService.getExchangeClient();
+        const leverageResult = await exchangeClient.updateLeverage({
+            asset: assetId,
+            isCross: marginMode === 'cross',
+            leverage,
+        });
+        if (leverageResult.status !== 'ok') {
+            throw new Error(`Failed to update leverage: ${JSON.stringify(leverageResult)}`);
         }
         this.#deps.debugLogger.log('Leverage updated successfully:', {
             symbol,
@@ -4484,7 +4216,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async #handleHip3PreOrder(params) {
-        const { accountContext, dexName, symbol, orderPrice, positionSize, leverage, isBuy, } = params;
+        const { dexName, symbol, orderPrice, positionSize, leverage, isBuy } = params;
         // TAT-3304: Only USDC-collateral HIP-3 DEXs are supported for trading.
         // Following the USDH sunset, reject orders on any non-USDC-collateral
         // DEX here instead of attempting the (now-removed) USDH auto-swap path.
@@ -4522,7 +4254,6 @@ export class HyperLiquidProvider {
             const transferInfo = await this.#autoTransferForHip3Order({
                 targetDex: dexName,
                 requiredMargin: requiredMarginWithBuffer,
-                accountContext,
             });
             return { transferInfo };
         }
@@ -4547,7 +4278,7 @@ export class HyperLiquidProvider {
         const exchangeClient = this.#clientService.getExchangeClient();
         const builder = params.chargesMetamaskBuilderFee
             ? await this.#getBuilderOrderContext(params.builderFeeSetupContext ??
-                (await this.#ensureBuilderFeeSetup(undefined, {}, params.accountContext)))
+                (await this.#ensureBuilderFeeSetup()))
             : undefined;
         this.#deps.debugLogger.log('Submitting order via asset ID routing', {
             symbol,
@@ -4558,7 +4289,6 @@ export class HyperLiquidProvider {
             isHip3: Boolean(dexName),
         });
         try {
-            await this.#assertNoKnownUnsupportedAccount(params.accountContext, 'Order submission');
             const result = await exchangeClient.order({
                 orders: this.#applySubscriptionCloid(orders),
                 grouping,
@@ -4568,9 +4298,6 @@ export class HyperLiquidProvider {
                 throw new Error(`Order failed: ${JSON.stringify(result)}`);
             }
             const status = result.response?.data?.statuses?.[0];
-            if (hasProperty(status, 'error') && typeof status.error === 'string') {
-                throw createStatusError(status.error, result);
-            }
             // Note: `in` narrows the HyperLiquid SDK discriminated union to the
             // branch that has the property; `hasProperty` types the property as
             // `unknown`, losing downstream access to `.oid`, `.totalSz`, `.avgPx`.
@@ -4580,11 +4307,7 @@ export class HyperLiquidProvider {
             /* eslint-enable no-restricted-syntax */
             // Success - auto-rebalance excess funds
             if (isHip3Order && transferInfo && dexName) {
-                await this.#handleHip3PostOrderRebalance({
-                    accountContext: params.accountContext,
-                    dexName,
-                    transferInfo,
-                });
+                await this.#handleHip3PostOrderRebalance({ dexName, transferInfo });
             }
             return {
                 success: true,
@@ -4600,14 +4323,9 @@ export class HyperLiquidProvider {
             };
         }
         catch (orderError) {
-            this.#recordUnsupportedAccountFromError(orderError, params.accountContext);
             // Failure - rollback transfer
             if (transferInfo && dexName) {
-                await this.#handleHip3OrderRollback({
-                    accountContext: params.accountContext,
-                    dexName,
-                    transferInfo,
-                });
+                await this.#handleHip3OrderRollback({ dexName, transferInfo });
             }
             throw orderError;
         }
@@ -4662,20 +4380,6 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async placeOrder(input, _retryCount = 0, reportFailure = true) {
-        return await this.#placeOrder(input, _retryCount, reportFailure);
-    }
-    /**
-     * Place an order while preserving one account context across parent actions
-     * and minimum-value retries.
-     *
-     * @param input - Order parameters.
-     * @param _retryCount - Unused. Preserves the public call shape internally.
-     * @param reportFailure - Whether this call owns provider-level reporting.
-     * @param expectedAccountContext - Context captured by a parent action or the
-     * first minimum-value attempt.
-     * @returns The order result.
-     */
-    async #placeOrder(input, _retryCount, reportFailure, expectedAccountContext) {
         const deferProviderErrorReport = input.deferProviderErrorReport === true;
         const params = { ...input };
         delete params.deferProviderErrorReport;
@@ -4686,7 +4390,6 @@ export class HyperLiquidProvider {
                 error: PERPS_ERROR_CODES.ORDER_SCALE_PREVIEW_STALE,
             };
         }
-        let actionAccountContext = expectedAccountContext;
         try {
             this.#deps.debugLogger.log('Placing order via HyperLiquid SDK:', params);
             // Basic sync validation (backward compatibility)
@@ -4714,7 +4417,7 @@ export class HyperLiquidProvider {
             // array, the HIP-3 transfer, and the atomic single-order submit, none of
             // which describe what a TWAP, a ladder, or a chase does.
             if (isStrategyOrderType(params.orderType)) {
-                return await this.#placeStrategyOrder(params, params.orderType, expectedAccountContext);
+                return await this.#placeStrategyOrder(params, params.orderType);
             }
             // Extract DEX name for API calls (main DEX = null)
             const { dex: dexName } = parseAssetName(params.symbol);
@@ -4763,11 +4466,9 @@ export class HyperLiquidProvider {
             // Kept after validation so invalid orders never trigger signature prompts
             // (builder-fee approval, DEX abstraction enablement, etc.).
             const { chargesMetamaskBuilderFee } = this.#resolveOrderFeePolicy(params);
-            const { accountContext, builderFeeSetupContext } = await this.#ensureReadyForTrading({
+            const builderFeeSetupContext = await this.#ensureReadyForTrading({
                 requiresBuilderFee: chargesMetamaskBuilderFee,
-                accountContext: actionAccountContext,
             });
-            actionAccountContext = accountContext;
             // Debug: Log asset map state before order placement
             const allMapKeys = Array.from(this.#symbolToAssetId.keys());
             const hip3Keys = allMapKeys.filter((key) => key.includes(':'));
@@ -4825,7 +4526,6 @@ export class HyperLiquidProvider {
                 assetId,
                 leverage: params.leverage,
                 marginMode: params.marginMode,
-                accountContext,
             });
             // 6. Handle HIP-3 balance management (if applicable)
             const isHip3Order = dexName !== null;
@@ -4833,7 +4533,6 @@ export class HyperLiquidProvider {
             if (isHip3Order && dexName) {
                 const effectiveLeverage = params.leverage ?? assetInfo.maxLeverage ?? 1;
                 const hip3Result = await this.#handleHip3PreOrder({
-                    accountContext,
                     dexName,
                     symbol: params.symbol,
                     orderPrice,
@@ -4876,7 +4575,6 @@ export class HyperLiquidProvider {
                 symbol: params.symbol,
                 assetId,
                 chargesMetamaskBuilderFee,
-                accountContext,
                 builderFeeSetupContext,
             });
         }
@@ -4909,16 +4607,15 @@ export class HyperLiquidProvider {
      *
      * @param params - Order parameters, already validated.
      * @param orderType - The strategy type, narrowed by the caller.
-     * @param expectedAccountContext - Context captured by a parent action.
      * @returns A promise that resolves to the result.
      */
-    async #placeStrategyOrder(params, orderType, expectedAccountContext) {
+    async #placeStrategyOrder(params, orderType) {
         // Captured before the shared preamble, not after it: that preamble awaits
         // asset info, validation, trading readiness and a leverage update, and a
         // disconnect during any of them has to be seen before or after submission.
         const generation = this.#strategyGeneration;
         if (orderType !== 'chase') {
-            const context = await this.#prepareStrategyPlacement(params, expectedAccountContext);
+            const context = await this.#prepareStrategyPlacement(params);
             return await this.#submitPreparedStrategy(params, context, async () => {
                 if (generation !== this.#strategyGeneration) {
                     throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
@@ -4951,7 +4648,7 @@ export class HyperLiquidProvider {
         this.#chasePlacementWaiters.add(placementWaiter);
         try {
             await this.#chaseTickQueue;
-            const context = await this.#prepareStrategyPlacement(params, expectedAccountContext);
+            const context = await this.#prepareStrategyPlacement(params);
             return await this.#submitPreparedStrategy(params, context, async () => await this.#startChaseSession(params, context, generation));
         }
         finally {
@@ -4977,36 +4674,24 @@ export class HyperLiquidProvider {
      * @returns The strategy placement result.
      */
     async #submitPreparedStrategy(params, context, submit) {
-        const { accountContext, dexName, network, transferInfo, userAddress } = context;
+        const { dexName, network, transferInfo, userAddress } = context;
         let result;
         try {
             result = await submit();
         }
         catch (error) {
-            this.#recordUnsupportedAccountFromError(error, accountContext);
             if (dexName && transferInfo) {
-                await this.#handleHip3OrderRollback({
-                    accountContext,
-                    dexName,
-                    transferInfo,
-                });
+                await this.#handleHip3OrderRollback({ dexName, transferInfo });
             }
             throw error;
         }
-        if (!result.success && result.error) {
-            this.#recordUnsupportedAccountFromError(new Error(result.error), accountContext);
-        }
         const resultFilledSize = new BigNumber(result.filledSize ?? 0);
         const hasVenueExposure = result.success === true ||
             result.orderId !== undefined ||
             (result.childOrderIds?.length ?? 0) > 0 ||
             (resultFilledSize.isFinite() && resultFilledSize.gt(0));
         if (dexName && transferInfo && !hasVenueExposure) {
-            await this.#handleHip3OrderRollback({
-                accountContext,
-                dexName,
-                transferInfo,
-            });
+            await this.#handleHip3OrderRollback({ dexName, transferInfo });
             return result;
         }
         if (params.orderType === 'twap' && result.orderId) {
@@ -5017,13 +4702,7 @@ export class HyperLiquidProvider {
             }), {
                 symbol: params.symbol,
                 ...(dexName && transferInfo
-                    ? {
-                        hip3Transfer: {
-                            accountContext,
-                            dexName,
-                            transferInfo,
-                        },
-                    }
+                    ? { hip3Transfer: { dexName, transferInfo } }
                     : {}),
             });
             return result;
@@ -5035,11 +4714,7 @@ export class HyperLiquidProvider {
             transferInfo) {
             const session = this.#chaseSessions.get(result.orderId);
             if (session) {
-                session.hip3Transfer = {
-                    accountContext,
-                    dexName,
-                    transferInfo,
-                };
+                session.hip3Transfer = { dexName, transferInfo };
                 return result;
             }
         }
@@ -5051,11 +4726,7 @@ export class HyperLiquidProvider {
             return result;
         }
         if (dexName && transferInfo) {
-            await this.#handleHip3PostOrderRebalance({
-                accountContext,
-                dexName,
-                transferInfo,
-            });
+            await this.#handleHip3PostOrderRebalance({ dexName, transferInfo });
         }
         return result;
     }
@@ -5067,10 +4738,9 @@ export class HyperLiquidProvider {
      * so a strategy order is held to the same rules as an ordinary one.
      *
      * @param params - Order parameters.
-     * @param expectedAccountContext - Context captured by a parent action.
      * @returns The asset and sizing context the strategy handlers submit with.
      */
-    async #prepareStrategyPlacement(params, expectedAccountContext) {
+    async #prepareStrategyPlacement(params) {
         const { dex: dexName } = parseAssetName(params.symbol);
         const { assetInfo, currentPrice, meta } = await this.#getAssetInfo({
             symbol: params.symbol,
@@ -5133,16 +4803,9 @@ export class HyperLiquidProvider {
         // Kept after validation so an invalid strategy order never triggers the
         // signature prompts in trading setup — same ordering as `placeOrder`.
         const { chargesMetamaskBuilderFee } = this.#resolveOrderFeePolicy(params);
-        const tradingActionContext = chargesMetamaskBuilderFee
-            ? await this.#ensureReadyForTrading({
-                requiresBuilderFee: true,
-                accountContext: expectedAccountContext,
-            })
-            : await this.#ensureReadyForTrading({
-                requiresBuilderFee: false,
-                accountContext: expectedAccountContext,
-            });
-        const { accountContext, builderFeeSetupContext } = tradingActionContext;
+        const builderFeeSetupContext = chargesMetamaskBuilderFee
+            ? await this.#ensureReadyForTrading({ requiresBuilderFee: true })
+            : await this.#ensureReadyForTrading({ requiresBuilderFee: false });
         const assetId = await this.#getAssetIdWithRepair({
             symbol: params.symbol,
             dexName,
@@ -5153,19 +4816,19 @@ export class HyperLiquidProvider {
             assetId,
             leverage: params.leverage,
             marginMode: params.marginMode,
-            accountContext,
         });
         const builder = builderFeeSetupContext
             ? await this.#getBuilderOrderContext(builderFeeSetupContext)
             : undefined;
-        const { network, userAddress } = accountContext;
+        const network = this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet';
+        const userAddress = builderFeeSetupContext?.userAddress ??
+            (await this.#walletService.getUserAddressWithDefault());
         let transferInfo = null;
         if (dexName) {
             const orderPrice = ladder === undefined
                 ? effectivePrice
                 : Math.max(...ladder.prices.map(Number.parseFloat));
             const hip3Result = await this.#handleHip3PreOrder({
-                accountContext,
                 dexName,
                 symbol: params.symbol,
                 orderPrice,
@@ -5177,7 +4840,6 @@ export class HyperLiquidProvider {
             transferInfo = hip3Result.transferInfo;
         }
         return {
-            accountContext,
             assetId,
             szDecimals: assetInfo.szDecimals,
             formattedSize,
@@ -5265,7 +4927,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async #placeTwapOrder(params, context, generation) {
-        const { accountContext, assetId, formattedSize } = context;
+        const { assetId, formattedSize } = context;
         const durationMinutes = params.twapDuration;
         if (durationMinutes === undefined) {
             throw new Error(PERPS_ERROR_CODES.ORDER_TWAP_DURATION_REQUIRED);
@@ -5283,7 +4945,6 @@ export class HyperLiquidProvider {
             durationMinutes,
             randomize: params.twapRandomize ?? false,
         });
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'TWAP order submission');
         const result = await exchangeClient.twapOrder({
             twap: {
                 a: assetId,
@@ -5313,7 +4974,6 @@ export class HyperLiquidProvider {
         if (generation !== this.#strategyGeneration) {
             let remainsLive = true;
             try {
-                await this.#assertRollbackAccountWritable(accountContext);
                 const cancelResult = await exchangeClient.twapCancel({
                     a: assetId,
                     t: running.twapId,
@@ -5361,7 +5021,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async #placeScaleOrder(params, context, generation) {
-        const { accountContext, assetId, formattedSize, ladder, builder } = context;
+        const { assetId, formattedSize, ladder, builder } = context;
         // Built and validated in `#prepareStrategyPlacement`, before anything was
         // signed, so what is submitted here is exactly what the minimums were
         // applied to.
@@ -5402,7 +5062,6 @@ export class HyperLiquidProvider {
         let result;
         let thrownBulkOrderError;
         try {
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Scale order submission');
             result = await exchangeClient.order({
                 orders,
                 grouping: 'na',
@@ -5419,7 +5078,6 @@ export class HyperLiquidProvider {
         }
         const rawStatuses = result.response?.data?.statuses;
         const statuses = Array.isArray(rawStatuses) ? rawStatuses : [];
-        const isMultiSigRequired = this.#recordUnsupportedAccountFromStatuses(statuses, result, accountContext);
         const outcomes = Array.from({ length: count }, (_unused, index) => parseScaleBulkOrderStatus(statuses[index]));
         const acceptedCount = outcomes.filter((outcome) => outcome?.kind === 'accepted').length;
         const everyStatusClassified = outcomes.every((outcome) => outcome !== undefined);
@@ -5472,19 +5130,6 @@ export class HyperLiquidProvider {
             ...acceptedResult,
         });
         const cancelNonRejectedOrders = async () => {
-            try {
-                await this.#assertRollbackAccountWritable(accountContext);
-            }
-            catch (error) {
-                this.#deps.debugLogger.log('Scale placement rollback not signed after its account context changed', {
-                    error: ensureError(error, 'HyperLiquidProvider.placeScaleOrder.rollback').message,
-                    groupId,
-                });
-                return {
-                    orderIds: restingChildOrderIds,
-                    clientOrderIds: cleanupClientOrderIds,
-                };
-            }
             const [orderIds, pendingClientOrderIds] = await Promise.all([
                 this.#cancelOrderRequests(exchangeClient, restingChildOrderIds.map((orderId) => ({
                     a: assetId,
@@ -5574,9 +5219,7 @@ export class HyperLiquidProvider {
                     childOrderIds: [],
                 });
             }
-            throw new Error(isMultiSigRequired
-                ? PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED
-                : PERPS_ERROR_CODES.ORDER_REJECTED);
+            throw new Error(PERPS_ERROR_CODES.ORDER_REJECTED);
         }
         this.#scaleOrderGroups.set(groupId, {
             symbol: params.symbol,
@@ -5597,7 +5240,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async #startChaseSession(params, context, generation) {
-        const { accountContext, assetId, szDecimals, formattedSize, builder } = context;
+        const { assetId, szDecimals, formattedSize, builder } = context;
         // Captured now, alongside the builder fee and for the same reason: the fee
         // resolution behind it is cleared when the caller's `placeOrder` returns,
         // which for a chase is before any replacement runs.
@@ -5645,7 +5288,6 @@ export class HyperLiquidProvider {
                     reduceOnly: params.reduceOnly ?? false,
                     builder,
                     marksSubscriptionCloid,
-                    accountContext,
                     exchangeClient: placingClient,
                 });
                 break;
@@ -5679,7 +5321,6 @@ export class HyperLiquidProvider {
         const intervalMs = params.chaseIntervalMs ?? CHASE_ORDER_CONFIG.DefaultIntervalMs;
         const sessionId = generatePerpsId('chase');
         const session = {
-            accountContext,
             symbol: params.symbol,
             assetId,
             isBuy: params.isBuy,
@@ -5814,12 +5455,9 @@ export class HyperLiquidProvider {
      * than looked up here so a first placement can keep the instance it signed
      * with, which is the only one that can take the order back once `disconnect`
      * has dropped the service's reference.
-     * @param params.accountContext - Account/network/lifecycle captured by the
-     * action that owns the chase.
      * @returns The resting order's exchange ID.
      */
     async #restChaseOrder(params) {
-        await this.#assertNoKnownUnsupportedAccount(params.accountContext, 'Chase order submission');
         const result = await params.exchangeClient.order({
             orders: this.#applySubscriptionCloid([
                 {
@@ -5860,15 +5498,6 @@ export class HyperLiquidProvider {
             this.#chaseTickQueue = this.#chaseTickQueue
                 .then(() => this.#runChaseTick(sessionId))
                 .catch(async (error) => {
-                const failedSession = this.#chaseSessions.get(sessionId);
-                const accountUnsupported = failedSession
-                    ? this.#recordUnsupportedAccountFromError(error, failedSession.accountContext)
-                    : false;
-                if (accountUnsupported) {
-                    this.#stopChaseSession(sessionId);
-                    this.#deps.debugLogger.log('Chase stopped after account support correction', { sessionId });
-                    return;
-                }
                 // A rejected agent is dropped so the next tick asks for another.
                 await this.#evictRejectedAgent(error);
                 // Resolve the shared queue after every failure. Otherwise one
@@ -6183,7 +5812,8 @@ export class HyperLiquidProvider {
                         reduceOnly: session.reduceOnly,
                         builder: session.builder,
                         marksSubscriptionCloid: session.marksSubscriptionCloid,
-                        accountContext: session.accountContext,
+                        // A running session is on a live provider, so the current client is
+                        // the right one; only the first placement has a teardown to survive.
                         exchangeClient: this.#clientService.getExchangeClient(),
                     });
                     session.size = remaining;
@@ -6415,9 +6045,6 @@ export class HyperLiquidProvider {
         }
         // Looked up only once there is something to cancel, so a session with
         // nothing resting still answers on a provider whose client is already gone.
-        if (!placingClient) {
-            await this.#assertNoKnownUnsupportedAccount(session.accountContext, 'Chase cancellation');
-        }
         const exchangeClient = placingClient ?? this.#clientService.getExchangeClient();
         let result;
         try {
@@ -6426,7 +6053,6 @@ export class HyperLiquidProvider {
             });
         }
         catch (error) {
-            this.#recordUnsupportedAccountFromError(error, session.accountContext);
             const message = ensureError(error, 'HyperLiquidProvider.cancelChaseChild').message.toLowerCase();
             if (ALREADY_GONE_CANCEL_MARKERS.some((marker) => message.includes(marker))) {
                 return CancelChildOutcome.Gone;
@@ -6434,9 +6060,6 @@ export class HyperLiquidProvider {
             throw error;
         }
         const status = result.response?.data?.statuses?.[0];
-        if (isStatusObject(status) && typeof status.error === 'string') {
-            this.#recordUnsupportedAccountFromError(createStatusError(status.error, result), session.accountContext);
-        }
         const signerFailure = await this.#classifyStatusSignerFailure([status], result);
         if (signerFailure) {
             throw signerFailure;
@@ -6635,16 +6258,7 @@ export class HyperLiquidProvider {
         }
         let { rebalancePromise } = trackedOrder;
         if (!rebalancePromise) {
-            const { hip3Transfer } = trackedOrder;
-            rebalancePromise = this.#handleHip3PostOrderRebalance({
-                ...hip3Transfer,
-                accountContext: {
-                    ...hip3Transfer.accountContext,
-                    // TWAP tracking deliberately survives reconnects. Keep its stable
-                    // account/network scope, but bind the cleanup write to this lifecycle.
-                    lifecycleGeneration: this.#lifecycleGeneration,
-                },
-            });
+            rebalancePromise = this.#handleHip3PostOrderRebalance(trackedOrder.hip3Transfer);
             trackedOrder.rebalancePromise = rebalancePromise;
         }
         try {
@@ -6897,10 +6511,9 @@ export class HyperLiquidProvider {
         if (!/^\d+$/u.test(params.orderId) || !Number.isSafeInteger(twapId)) {
             throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
         }
-        const { accountContext } = await this.#ensureReadyForTrading({
-            requiresBuilderFee: false,
-        });
-        const { network, userAddress } = accountContext;
+        await this.#ensureReadyForTrading({ requiresBuilderFee: false });
+        const network = this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet';
+        const userAddress = await this.#walletService.getUserAddressWithDefault();
         const trackingKey = getTwapOrderScopeKey({
             network,
             userAddress,
@@ -6936,7 +6549,6 @@ export class HyperLiquidProvider {
             symbol: params.symbol,
             dexName: parseAssetName(params.symbol).dex,
         });
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'TWAP cancellation');
         const result = await this.#clientService.getExchangeClient().twapCancel({
             a: assetId,
             t: twapId,
@@ -6953,7 +6565,7 @@ export class HyperLiquidProvider {
         const rawError = isStatusObject(status) && typeof status.error === 'string'
             ? status.error
             : 'TWAP cancellation failed';
-        return createErrorResult(await this.#mapStatusError(rawError, result, accountContext), {
+        return createErrorResult(await this.#mapStatusError(rawError, result), {
             success: false,
             orderId: params.orderId,
         });
@@ -6969,9 +6581,7 @@ export class HyperLiquidProvider {
         if (!group) {
             throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
         }
-        const { accountContext } = await this.#ensureReadyForTrading({
-            requiresBuilderFee: false,
-        });
+        await this.#ensureReadyForTrading({ requiresBuilderFee: false });
         const assetId = await this.#getAssetIdWithRepair({
             symbol: group.symbol,
             dexName: parseAssetName(group.symbol).dex,
@@ -6985,14 +6595,9 @@ export class HyperLiquidProvider {
             asset: assetId,
             cloid: clientOrderId,
         }));
-        await this.#assertNoKnownUnsupportedAccount(accountContext, 'Scale cancellation');
         const [orderCancellation, cloidCancellation] = await Promise.all([
-            this.#cancelOrderRequestBatch(exchangeClient, cancelRequests, (error) => {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
-            }),
-            this.#cancelOrderCloidRequestBatch(exchangeClient, cancelByCloidRequests, (error) => {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
-            }),
+            this.#cancelOrderRequestBatch(exchangeClient, cancelRequests),
+            this.#cancelOrderCloidRequestBatch(exchangeClient, cancelByCloidRequests),
         ]);
         const remaining = orderCancellation.remainingOrderIds.map(String);
         const { remainingClientOrderIds } = cloidCancellation;
@@ -7092,18 +6697,7 @@ export class HyperLiquidProvider {
             }
             return { success: true, orderId: params.orderId };
         }
-        this.#assertProviderLifecycleCurrent(session.accountContext.lifecycleGeneration, 'Chase cancellation setup');
-        const currentAddress = await this.#walletService.getUserAddressWithDefault();
-        if (currentAddress.toLowerCase() !==
-            session.accountContext.userAddress.toLowerCase() ||
-            (this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet') !==
-                session.accountContext.network) {
-            throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
-        }
-        await this.#ensureReadyForTrading({
-            requiresBuilderFee: false,
-            accountContext: session.accountContext,
-        });
+        await this.#ensureReadyForTrading({ requiresBuilderFee: false });
         // Only a refusal leaves an order behind. A child that had already filled or
         // been cancelled is reported as a rejection too, but nothing of it is
         // resting — treating that as a failure would pin the handle open forever on
@@ -7147,11 +6741,11 @@ export class HyperLiquidProvider {
      *
      * @param exchangeClient - Client that owns the orders.
      * @param requests - Venue cancel-by-CLOID requests.
-     * @param onError - Optional operation-specific failure classifier.
      * @returns Client order IDs that may still be resting.
      */
-    async #cancelOrderCloidRequests(exchangeClient, requests, onError) {
-        return (await this.#cancelOrderCloidRequestBatch(exchangeClient, requests, onError)).remainingClientOrderIds;
+    async #cancelOrderCloidRequests(exchangeClient, requests) {
+        return (await this.#cancelOrderCloidRequestBatch(exchangeClient, requests))
+            .remainingClientOrderIds;
     }
     /**
      * Cancel pending orders by client order ID, reporting a signer that could
@@ -7159,20 +6753,14 @@ export class HyperLiquidProvider {
      *
      * @param exchangeClient - Client that owns the orders.
      * @param requests - Venue cancel-by-CLOID requests.
-     * @param onError - Optional operation-specific failure classifier.
      * @returns Client order IDs that may still be resting, and the signer
      * failure when the signer could not sign the request.
      */
-    async #cancelOrderCloidRequestBatch(exchangeClient, requests, onError) {
+    async #cancelOrderCloidRequestBatch(exchangeClient, requests) {
         if (requests.length === 0) {
             return { remainingClientOrderIds: [] };
         }
         const classifyStatuses = async (statuses, answer) => {
-            for (const status of statuses) {
-                if (isStatusObject(status) && typeof status.error === 'string') {
-                    await onError?.(createStatusError(status.error, answer));
-                }
-            }
             // A signer failure is classified (and reported) once for the request;
             // entries the venue cancelled are not resting either way.
             const signerFailure = await this.#classifyStatusSignerFailure(statuses, answer);
@@ -7196,7 +6784,6 @@ export class HyperLiquidProvider {
             return await classifyStatuses(statuses, result);
         }
         catch (error) {
-            await onError?.(error);
             // The SDK throws when any entry failed, with every entry's status.
             const statuses = getCancelStatusesFromError(error, requests.length);
             if (statuses) {
@@ -7237,11 +6824,6 @@ export class HyperLiquidProvider {
             };
         }
         const classifyStatuses = async (statuses, answer) => {
-            for (const status of statuses) {
-                if (isStatusObject(status) && typeof status.error === 'string') {
-                    await onError?.(createStatusError(status.error, answer));
-                }
-            }
             // A signer failure is classified (and reported) once for the request;
             // entries the venue cancelled still count as cancelled.
             const signerFailure = await this.#classifyStatusSignerFailure(statuses, answer);
@@ -7387,11 +6969,9 @@ export class HyperLiquidProvider {
      * Apply both signer invalidation and account-shape classification to writes.
      *
      * @param error - Failed protection write.
-     * @param accountContext - Account and network that authorized the write.
      * @returns Actionable error retaining the venue message when unmapped.
      */
-    async #classifyProtectionWriteError(error, accountContext) {
-        this.#recordUnsupportedAccountFromError(error, accountContext);
+    async #classifyProtectionWriteError(error) {
         return ((await this.#classifySignerFailure(error)) ??
             (isHyperLiquidMultiSigRequiredError(error)
                 ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
@@ -7798,30 +7378,19 @@ export class HyperLiquidProvider {
             // Every refusal is behind us, so shared trading readiness can run now.
             // HyperLiquid's modify action has no builder field and must not request a
             // builder-fee approval.
-            const { accountContext } = await this.#ensureReadyForTrading({
-                requiresBuilderFee: false,
-            });
+            await this.#ensureReadyForTrading({ requiresBuilderFee: false });
             // Submit modification via SDK. The cloid is deliberately left unmarked:
             // `modify` carries no builder field, as the readiness call above records,
             // so no MetaMask fee is charged on this action and marking it would tell
             // the fill fan-out a reduction applied to an order that paid nothing.
             // The replacement inherits the resting order's own attribution.
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Order modification');
             const exchangeClient = this.#clientService.getExchangeClient();
-            try {
-                const result = await exchangeClient.modify({
-                    oid: typeof params.orderId === 'string'
-                        ? params.orderId
-                        : params.orderId,
-                    order: newOrder,
-                });
-                if (result.status !== 'ok') {
-                    throw new Error(`Order modification failed: ${JSON.stringify(result)}`);
-                }
-            }
-            catch (error) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
-                throw error;
+            const result = await exchangeClient.modify({
+                oid: typeof params.orderId === 'string' ? params.orderId : params.orderId,
+                order: newOrder,
+            });
+            if (result.status !== 'ok') {
+                throw new Error(`Order modification failed: ${JSON.stringify(result)}`);
             }
             // `params.orderId` is the order that was just REPLACED, so returning it
             // as OrderResult.orderId (documented as the exchange order ID) names an
@@ -7881,7 +7450,6 @@ export class HyperLiquidProvider {
         // current child instead of leaving a replacement chasing behind the user.
         const owningChase = [...this.#chaseSessions.entries()].find(([, session]) => session.orderId === params.orderId ||
             session.replacingOrderId === params.orderId);
-        let accountContext;
         try {
             if (owningChase) {
                 this.#stopChaseSession(owningChase[0]);
@@ -7904,15 +7472,12 @@ export class HyperLiquidProvider {
             if (!coinValidation.isValid) {
                 throw new Error(coinValidation.error);
             }
-            ({ accountContext } = await this.#ensureReadyForTrading({
-                requiresBuilderFee: false,
-            }));
+            await this.#ensureReadyForTrading({ requiresBuilderFee: false });
+            const exchangeClient = this.#clientService.getExchangeClient();
             const asset = await this.#getAssetIdWithRepair({
                 symbol: params.symbol,
                 dexName: parseAssetName(params.symbol).dex,
             });
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Order cancellation');
-            const exchangeClient = this.#clientService.getExchangeClient();
             const result = await exchangeClient.cancel({
                 cancels: [
                     {
@@ -7935,15 +7500,12 @@ export class HyperLiquidProvider {
             const rawError = isStatusObject(status) && typeof status.error === 'string'
                 ? status.error
                 : 'Order cancellation failed';
-            return createErrorResult(await this.#mapStatusError(rawError, result, accountContext), {
+            return createErrorResult(await this.#mapStatusError(rawError, result), {
                 success: false,
                 orderId: params.orderId,
             });
         }
         catch (error) {
-            if (accountContext) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
-            }
             const mappedError = await this.#reportWriteError(error, 'cancelOrder', {
                 orderId: params.orderId,
                 coin: params.symbol,
@@ -8015,9 +7577,8 @@ export class HyperLiquidProvider {
             if (ordinaryOrders.length > 0) {
                 // Cancellation carries no builder context, so it must not prompt for a
                 // fee approval that the action cannot use.
-                const { accountContext } = await this.#ensureReadyForTrading({
-                    requiresBuilderFee: false,
-                });
+                await this.#ensureReadyForTrading({ requiresBuilderFee: false });
+                const exchangeClient = this.#clientService.getExchangeClient();
                 const cancelRequests = await Promise.all(ordinaryOrders.map(async ({ order }) => {
                     const asset = await this.#getAssetIdWithRepair({
                         symbol: order.symbol,
@@ -8028,8 +7589,6 @@ export class HyperLiquidProvider {
                         o: parseInt(order.orderId, 10),
                     };
                 }));
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Batch order cancellation');
-                const exchangeClient = this.#clientService.getExchangeClient();
                 let statuses;
                 let answer;
                 try {
@@ -8064,7 +7623,6 @@ export class HyperLiquidProvider {
                             : undefined;
                         let error = PERPS_ERROR_CODES.BATCH_CANCEL_FAILED;
                         if (statusError) {
-                            this.#recordUnsupportedAccountFromError(statusError, accountContext);
                             error =
                                 signerFailure && (await this.#isSignerFailure(statusError))
                                     ? signerFailure.message
@@ -8108,14 +7666,11 @@ export class HyperLiquidProvider {
     async closePositions(params) {
         // Declare outside try block so it's accessible in catch block
         let positionsToClose = [];
-        let accountContext;
         const unavailableResults = [];
         try {
             // Batch preparation needs trading readiness but not builder approval yet.
             // The provider-owned market policy is resolved from the positions below.
-            ({ accountContext } = await this.#ensureReadyForTrading({
-                requiresBuilderFee: false,
-            }));
+            await this.#ensureReadyForTrading({ requiresBuilderFee: false });
             // Selected symbols only need the DEXes they belong to. Loading every
             // market group would refuse a BTC close when an unrelated HIP-3 DEX
             // cannot be read. closeAll / empty symbols still need a complete
@@ -8186,6 +7741,8 @@ export class HyperLiquidProvider {
                     results: unavailableResults,
                 };
             }
+            // Get exchange client for order submission
+            const exchangeClient = this.#clientService.getExchangeClient();
             // Pre-fetch meta for all unique DEXs to avoid N API calls in loop
             const uniqueDexs = [
                 ...new Set(positionsToClose.map((pos) => parseAssetName(pos.symbol).dex ?? 'main')),
@@ -8300,16 +7857,10 @@ export class HyperLiquidProvider {
             // policy charges, preserving deterministic behavior for future policies
             // that vary by market or route.
             const chargesMetamaskBuilderFee = feePolicyContexts.some((context) => this.#resolveOrderFeePolicy(context).chargesMetamaskBuilderFee);
-            let builder;
-            if (chargesMetamaskBuilderFee) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Batch close setup');
-                const builderFeeSetupContext = await this.#ensureBuilderFeeSetup(undefined, {}, accountContext);
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Batch close setup');
-                builder = await this.#getBuilderOrderContext(builderFeeSetupContext);
-            }
+            const builder = chargesMetamaskBuilderFee
+                ? await this.#getBuilderOrderContext(await this.#ensureReadyForTrading({ requiresBuilderFee: true }))
+                : undefined;
             // Single batch API call
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Batch close submission');
-            const exchangeClient = this.#clientService.getExchangeClient();
             const result = await exchangeClient.order({
                 orders: this.#applySubscriptionCloid(orders),
                 grouping: 'na',
@@ -8317,11 +7868,6 @@ export class HyperLiquidProvider {
             });
             // Parse response statuses (one per order)
             const { statuses } = result.response.data;
-            for (const status of statuses) {
-                if (hasProperty(status, 'error') && typeof status.error === 'string') {
-                    this.#recordUnsupportedAccountFromError(createStatusError(status.error, result), accountContext);
-                }
-            }
             const successCount = statuses.filter((stat) => isStatusObject(stat) &&
                 (hasProperty(stat, 'filled') || hasProperty(stat, 'resting'))).length;
             const failureCount = statuses.length -
@@ -8340,7 +7886,6 @@ export class HyperLiquidProvider {
                         this.#deps.debugLogger.log('Position closed successfully, initiating manual auto-transfer back', { symbol: orderedPositions[i].symbol, freedMargin });
                         // Non-blocking: Transfer freed margin back to main DEX
                         await this.#autoTransferBackAfterClose({
-                            accountContext,
                             sourceDex,
                             freedMargin,
                         });
@@ -8376,9 +7921,6 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            if (accountContext) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
-            }
             const signerFailure = await this.#handleSignerFailure(error, 'closePositions', {
                 positionCount: positionsToClose.length,
             });
@@ -8462,11 +8004,6 @@ export class HyperLiquidProvider {
             const lifecycle = this.#lifecycleGeneration;
             const isTestnet = this.#clientService.isTestnetMode();
             const userAddress = await this.#walletService.getUserAddressWithDefault();
-            const accountContext = {
-                lifecycleGeneration: lifecycle,
-                network: isTestnet ? 'testnet' : 'mainnet',
-                userAddress,
-            };
             const assertScope = async () => {
                 const current = await this.#walletService.getUserAddressWithDefault();
                 this.#assertProviderLifecycleCurrent(lifecycle, 'updatePositionTPSL');
@@ -8862,18 +8399,12 @@ export class HyperLiquidProvider {
             const requiresBuilderFee = replacementChargesMetamaskBuilderFee || rollbackRequiresBuilderFee;
             // Approval and builder-context resolution both finish before the
             // pre-cancel. A failure here therefore leaves the old protection intact.
-            await assertScope();
-            const tradingActionContext = requiresBuilderFee
+            const builderFeeSetupContext = requiresBuilderFee
                 ? await this.#ensureReadyForTrading({
                     requiresBuilderFee: true,
                     builderFeeApprovalFailureCode: PERPS_ERROR_CODES.TPSL_UPDATE_FAILED,
-                    accountContext,
                 })
-                : await this.#ensureReadyForTrading({
-                    requiresBuilderFee: false,
-                    accountContext,
-                });
-            const { builderFeeSetupContext } = tradingActionContext;
+                : await this.#ensureReadyForTrading({ requiresBuilderFee: false });
             const builderOrderContext = builderFeeSetupContext
                 ? await this.#getBuilderOrderContext(builderFeeSetupContext)
                 : undefined;
@@ -8918,10 +8449,9 @@ export class HyperLiquidProvider {
                                 builderOrderContext && { builder: builderOrderContext }),
                         });
                         statuses = result.response?.data?.statuses ?? [];
-                        this.#recordUnsupportedAccountFromStatuses(statuses, result, accountContext);
                     }
                     catch (error) {
-                        const failure = await this.#classifyProtectionWriteError(error, accountContext);
+                        const failure = await this.#classifyProtectionWriteError(error);
                         restorationFailure = failure;
                         statuses =
                             this.#readProtectionErrorStatuses(error) ??
@@ -8975,10 +8505,10 @@ export class HyperLiquidProvider {
             await assertCurrentPosition();
             const oldCancellation = await this.#cancelOrderRequestBatch(exchangeClient, cancelRequests, async (error) => {
                 if (cancelGuardFailure !== undefined) {
-                    throw await this.#classifyProtectionWriteError(cancelGuardFailure, accountContext);
+                    throw await this.#classifyProtectionWriteError(cancelGuardFailure);
                 }
                 if (isHyperLiquidMultiSigRequiredError(error)) {
-                    throw await this.#classifyProtectionWriteError(error, accountContext);
+                    throw await this.#classifyProtectionWriteError(error);
                 }
             });
             // The signer could not sign the cancel. With nothing cancelled the old
@@ -9076,12 +8606,11 @@ export class HyperLiquidProvider {
                         builderOrderContext && { builder: builderOrderContext }),
                 });
                 placementStatuses = result.response?.data?.statuses ?? [];
-                this.#recordUnsupportedAccountFromStatuses(placementStatuses, result, accountContext);
                 responseAccepted = result.status === 'ok';
             }
             catch (error) {
                 // Drop and report a rejected agent before restoration signs.
-                placementFailure = await this.#classifyProtectionWriteError(error, accountContext);
+                placementFailure = await this.#classifyProtectionWriteError(error);
                 await assertScope();
                 const statuses = this.#readProtectionErrorStatuses(error);
                 if (statuses !== undefined) {
@@ -9197,7 +8726,7 @@ export class HyperLiquidProvider {
                         error.message === PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)) {
                     // Old protection has already changed. Classification must not
                     // throw away this batch's still-live replacement identities.
-                    cleanupFailure = await this.#classifyProtectionWriteError(error, accountContext);
+                    cleanupFailure = await this.#classifyProtectionWriteError(error);
                 }
             });
             await assertScope();
@@ -9275,9 +8804,7 @@ export class HyperLiquidProvider {
             this.#deps.debugLogger.log('Closing position:', params);
             // The delegated placeOrder call resolves the builder-fee policy for the
             // concrete close order after validation.
-            const { accountContext } = await this.#ensureReadyForTrading({
-                requiresBuilderFee: false,
-            });
+            await this.#ensureReadyForTrading({ requiresBuilderFee: false });
             // A caller snapshot is never authoritative for a reduce-only close. Use
             // the current DEX slice or its HTTP fallback, and fail closed if neither
             // answers. This keeps the size and side on one freshness contract across
@@ -9356,8 +8883,7 @@ export class HyperLiquidProvider {
             // position.
             const isFullClose = closeSizeNum >= absPositionSize;
             // Execute position close with consistent slippage handling
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Position close');
-            const result = await this.#placeOrder({
+            const result = await this.placeOrder({
                 symbol: params.symbol,
                 isBuy,
                 size: closeSize,
@@ -9377,7 +8903,7 @@ export class HyperLiquidProvider {
                 usdAmount: isFullClose ? undefined : params.usdAmount,
                 priceAtCalculation: params.priceAtCalculation,
                 maxSlippageBps: params.maxSlippageBps,
-            }, 0, false, accountContext);
+            }, 0, false);
             // Return freed margin using native abstraction or programmatic transfer
             if (result.success &&
                 isHip3Position &&
@@ -9386,7 +8912,6 @@ export class HyperLiquidProvider {
                 this.#deps.debugLogger.log('Position closed successfully, initiating manual auto-transfer back');
                 // Non-blocking: Transfer freed margin back to main DEX
                 await this.#autoTransferBackAfterClose({
-                    accountContext,
                     sourceDex: hip3Dex,
                     freedMargin,
                 });
@@ -9429,13 +8954,11 @@ export class HyperLiquidProvider {
      * - ntli: Amount in micro-units (amount * 1e6)
      */
     async updateMargin(params) {
-        let accountContext;
         try {
             this.#deps.debugLogger.log('Updating position margin:', params);
             const { symbol, amount } = params;
             // Ensure provider is ready
             await this.#ensureReady();
-            accountContext = await this.#assertAccountSupported();
             // Use the target DEX's current slice or one targeted HTTP read before
             // deriving the position side.
             const positions = await this.#getPositionsForOperation(parseAssetName(symbol).dex ?? '');
@@ -9471,7 +8994,6 @@ export class HyperLiquidProvider {
                 }
             }
             // Call SDK to update isolated margin
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Margin update');
             const exchangeClient = this.#clientService.getExchangeClient();
             const result = await exchangeClient.updateIsolatedMargin({
                 asset: assetId,
@@ -9487,18 +9009,13 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            const isMultiSigRequired = accountContext
-                ? this.#recordUnsupportedAccountFromError(error, accountContext)
-                : false;
             const signerFailure = await this.#handleSignerFailure(error, 'updateMargin', {
                 symbol: params.symbol,
             });
             if (signerFailure) {
                 return { success: false, error: signerFailure.message };
             }
-            const safeError = isMultiSigRequired
-                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
-                : ensureError(error, 'HyperLiquidProvider.updateMargin');
+            const safeError = ensureError(error, 'HyperLiquidProvider.updateMargin');
             this.#deps.logger.error(safeError, this.#getErrorContext('updateMargin', {
                 symbol: params.symbol,
                 amount: params.amount,
@@ -10387,22 +9904,6 @@ export class HyperLiquidProvider {
             return [];
         }
     }
-    /**
-     * Return whether the active wallet can submit Hyperliquid actions.
-     *
-     * @returns The provider-owned account support result.
-     */
-    async getAccountSupport() {
-        await this.#ensureReady();
-        const context = {
-            lifecycleGeneration: this.#lifecycleGeneration,
-            network: this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet',
-            userAddress: await this.#walletService.getUserAddressWithDefault(),
-        };
-        const support = await this.#getAccountSupportForContext(context);
-        await this.#assertAccountContextCurrent(context, 'Account support read');
-        return support;
-    }
     /**
      * Resolve the provider's currently active CAIP account identifier.
      * Used by the MarketDataService REST coalesce layer so cached payloads
@@ -11442,7 +10943,6 @@ export class HyperLiquidProvider {
      * @returns Result with txHash (HyperLiquid internal) and withdrawal ID
      */
     async withdraw(params) {
-        let accountContext;
         try {
             this.#deps.debugLogger.log('HyperLiquidProvider: STARTING WITHDRAWAL', {
                 params,
@@ -11495,16 +10995,6 @@ export class HyperLiquidProvider {
             this.#deps.debugLogger.log('HyperLiquidProvider: ASSET SUPPORTED', {
                 assetId: params.assetId,
             });
-            const lifecycleGeneration = this.#lifecycleGeneration;
-            const network = this.#clientService.isTestnetMode()
-                ? 'testnet'
-                : 'mainnet';
-            const userAddress = await this.#walletService.getUserAddressWithDefault();
-            accountContext = {
-                lifecycleGeneration,
-                network,
-                userAddress,
-            };
             // Step 3: Determine destination address
             this.#deps.debugLogger.log('HyperLiquidProvider: DETERMINING DESTINATION ADDRESS');
             let destination;
@@ -11515,7 +11005,7 @@ export class HyperLiquidProvider {
                 });
             }
             else {
-                destination = userAddress;
+                destination = await this.#walletService.getUserAddressWithDefault();
                 this.#deps.debugLogger.log('HyperLiquidProvider: USING USER WALLET ADDRESS', {
                     destination,
                 });
@@ -11523,12 +11013,7 @@ export class HyperLiquidProvider {
             // Step 4: Ensure client is ready
             this.#deps.debugLogger.log('HyperLiquidProvider: ENSURING CLIENT READY');
             await this.#ensureReady();
-            accountContext = await this.#assertAccountSupported(accountContext);
-            await this.#ensureUnifiedAccountEnabled({
-                allowUserSigning: true,
-                accountContext,
-            });
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Withdrawal');
+            await this.#ensureUnifiedAccountEnabled({ allowUserSigning: true });
             const exchangeClient = this.#clientService.getExchangeClient();
             this.#deps.debugLogger.log('HyperLiquidProvider: CLIENT READY');
             // Step 5: Validate amount against account balance
@@ -11578,7 +11063,6 @@ export class HyperLiquidProvider {
                 endpoint: 'withdraw3',
                 timestamp: new Date().toISOString(),
             });
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'Withdrawal');
             const result = await exchangeClient.withdraw3({
                 destination,
                 amount: params.amount,
@@ -11605,11 +11089,7 @@ export class HyperLiquidProvider {
                     // HyperLiquid's withdraw3 API doesn't return a transaction hash immediately
                 };
             }
-            const rejection = new Error(`Withdrawal failed: ${JSON.stringify(result)}`);
-            const isMultiSigRequired = this.#recordUnsupportedAccountFromError(rejection, accountContext);
-            const errorMessage = isMultiSigRequired
-                ? PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED
-                : `Withdrawal failed: ${String(result.status)}`;
+            const errorMessage = `Withdrawal failed: ${String(result.status)}`;
             this.#deps.debugLogger.log('HyperLiquidProvider: WITHDRAWAL FAILED', {
                 error: errorMessage,
                 status: result.status,
@@ -11622,18 +11102,13 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            const isMultiSigRequired = accountContext
-                ? this.#recordUnsupportedAccountFromError(error, accountContext)
-                : false;
             const signerFailure = await this.#handleSignerFailure(error, 'withdraw', {
                 assetId: params.assetId,
             });
             if (signerFailure) {
                 return createErrorResult(signerFailure, { success: false });
             }
-            const safeError = isMultiSigRequired
-                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
-                : ensureError(error, 'HyperLiquidProvider.initiateWithdrawal');
+            const safeError = ensureError(error, 'HyperLiquidProvider.initiateWithdrawal');
             this.#deps.debugLogger.log('HyperLiquidProvider: WITHDRAWAL EXCEPTION', {
                 error: safeError.message,
                 errorType: safeError.name,
@@ -11649,7 +11124,7 @@ export class HyperLiquidProvider {
                 operation: PERPS_ERROR_OPERATION.FinancialOperations,
                 action: PERPS_ERROR_ACTION.FinancialWithdrawal,
             }));
-            return createErrorResult(safeError, { success: false });
+            return createErrorResult(error, { success: false });
         }
     }
     /**
@@ -11672,17 +11147,6 @@ export class HyperLiquidProvider {
      * });
      */
     async transferBetweenDexs(params) {
-        return await this.#transferBetweenDexs(params);
-    }
-    /**
-     * Transfer collateral with an optional context captured by a parent action.
-     *
-     * @param params - Transfer parameters.
-     * @param expectedContext - Context captured by the parent action.
-     * @returns The transfer result.
-     */
-    async #transferBetweenDexs(params, expectedContext) {
-        let accountContext;
         try {
             this.#deps.debugLogger.log('HyperLiquidProvider: STARTING DEX TRANSFER', {
                 params,
@@ -11695,13 +11159,14 @@ export class HyperLiquidProvider {
             if (params.sourceDex === params.destinationDex) {
                 throw new Error('Source and destination DEX must be different');
             }
-            // Ensure client ready
-            await this.#ensureReady();
-            accountContext = await this.#assertAccountSupported(expectedContext);
-            const { userAddress } = accountContext;
+            // Get user address
+            const userAddress = await this.#walletService.getUserAddressWithDefault();
             this.#deps.debugLogger.log('HyperLiquidProvider: USER ADDRESS', {
                 userAddress,
             });
+            // Ensure client ready
+            await this.#ensureReady();
+            const exchangeClient = this.#clientService.getExchangeClient();
             // Execute transfer using SDK sendAsset()
             // Note: SDK docs say "testnet-only" but it works on mainnet (verified via Phantom)
             this.#deps.debugLogger.log('HyperLiquidProvider: CALLING SEND_ASSET API', {
@@ -11709,8 +11174,6 @@ export class HyperLiquidProvider {
                 destinationDex: params.destinationDex || '(main)',
                 amount: params.amount,
             });
-            await this.#assertNoKnownUnsupportedAccount(accountContext, 'DEX transfer');
-            const exchangeClient = this.#clientService.getExchangeClient();
             const result = await exchangeClient.sendAsset({
                 destination: userAddress,
                 sourceDex: params.sourceDex,
@@ -11730,22 +11193,14 @@ export class HyperLiquidProvider {
                     // User can verify transfer in explorer by timestamp
                 };
             }
-            if (this.#recordUnsupportedAccountFromError(new Error(`DEX transfer failed: ${JSON.stringify(result)}`), accountContext)) {
-                throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
-            }
             throw new Error(PERPS_ERROR_CODES.TRANSFER_FAILED);
         }
         catch (error) {
-            const isMultiSigRequired = accountContext
-                ? this.#recordUnsupportedAccountFromError(error, accountContext)
-                : false;
             const signerFailure = await this.#handleSignerFailure(error, 'transferBetweenDexs', { sourceDex: params.sourceDex, destinationDex: params.destinationDex });
             if (signerFailure) {
                 return { success: false, error: signerFailure.message };
             }
-            const safeError = isMultiSigRequired
-                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
-                : ensureError(error, 'HyperLiquidProvider.transferToSpot');
+            const safeError = ensureError(error, 'HyperLiquidProvider.transferToSpot');
             this.#deps.debugLogger.log('❌ HyperLiquidProvider: TRANSFER FAILED', {
                 error: safeError.message,
                 params,
@@ -11757,16 +11212,6 @@ export class HyperLiquidProvider {
             };
         }
     }
-    /**
-     * Transfer collateral using a context captured by a parent action.
-     *
-     * @param params - Transfer parameters.
-     * @param accountContext - Original action context for the transfer.
-     * @returns The transfer result.
-     */
-    async #transferBetweenDexsForContext(params, accountContext) {
-        return await this.#transferBetweenDexs(params, accountContext);
-    }
     /**
      * Subscribe to live price updates
      *
@@ -12049,11 +11494,6 @@ export class HyperLiquidProvider {
         try {
             const lifecycleGeneration = this.#lifecycleGeneration;
             const userAddress = await this.#walletService.getUserAddressWithDefault();
-            const preparationContext = {
-                lifecycleGeneration,
-                network: this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet',
-                userAddress,
-            };
             // The result is only for the provider and account it started with.
             const assertPreparationCurrent = async () => {
                 this.#assertProviderLifecycleCurrent(lifecycleGeneration, 'Trading wallet preparation');
@@ -12065,13 +11505,13 @@ export class HyperLiquidProvider {
                     throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
                 }
             };
-            const { accountContext } = await this.#ensureReadyForTrading({
+            await this.#ensureReadyForTrading({
                 requiresBuilderFee: false,
                 recheckPendingReferral: true,
-                accountContext: preparationContext,
             });
-            await assertPreparationCurrent();
-            const { network } = accountContext;
+            const network = this.#clientService.isTestnetMode()
+                ? 'testnet'
+                : 'mainnet';
             const isRegistered = await this.#isWalletOnHyperliquid(userAddress, network);
             await assertPreparationCurrent();
             // The venue rejects every write from a wallet with no HyperLiquid account
@@ -12087,7 +11527,7 @@ export class HyperLiquidProvider {
             await this.#ensureBuilderFeeSetup(undefined, {
                 reportSignerFailure: true,
                 reportRefusal: true,
-            }, accountContext);
+            });
             // The builder fee setup ends quietly when the provider disconnects.
             await assertPreparationCurrent();
             if (!this.#walletService.isMainAccountSignerReady()) {
@@ -12731,7 +12171,6 @@ export class HyperLiquidProvider {
             // Clear session caches. Capability and fee reads use the lifecycle
             // generation above to discard any old response that resolves later.
             this.clearFeeCache();
-            this.#accountSupportByContext.clear();
             this.#referralCheckCache.clear();
             this.#builderFeeCheckCache.clear();
             this.#builderFeeRefusals.clear();
@@ -12977,26 +12416,20 @@ export class HyperLiquidProvider {
      *
      * Note: This is network-specific - testnet and mainnet have separate referral states
      * Note: Non-blocking - failures are logged to Sentry but don't prevent trading
-     *
-     * @param accountContext - Account/network/lifecycle captured by the action
-     * that is allowed to authorize a referral write.
      */
-    async #ensureReferralSet(accountContext) {
+    async #ensureReferralSet() {
         this.#referralSetupNeedsRetry = false;
         this.#referralAwaitsBuilderCode = false;
-        const network = accountContext?.network ??
-            (this.#clientService.isTestnetMode() ? 'testnet' : 'mainnet');
-        const isTestnet = network === 'testnet';
+        const isTestnet = this.#clientService.isTestnetMode();
+        const network = isTestnet ? 'testnet' : 'mainnet';
         const expectedReferralCode = this.#getReferralCode(isTestnet);
         const referrerAddress = this.#getBuilderAddress(isTestnet);
-        let userAddress = accountContext?.userAddress;
-        if (!userAddress) {
-            try {
-                userAddress = await this.#walletService.getUserAddressWithDefault();
-            }
-            catch {
-                return; // Can't proceed without address
-            }
+        let userAddress;
+        try {
+            userAddress = await this.#walletService.getUserAddressWithDefault();
+        }
+        catch {
+            return; // Can't proceed without address
         }
         if (userAddress.toLowerCase() === referrerAddress.toLowerCase()) {
             this.#deps.debugLogger.log('[ensureReferralSet] User is builder, skipping', { network });
@@ -13038,9 +12471,6 @@ export class HyperLiquidProvider {
                 return;
             }
             const codeStatus = await this.#getReferralCodeStatus();
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Referral code lookup');
-            }
             if (codeStatus !== 'ready') {
                 this.#deps.debugLogger.log('[ensureReferralSet] Builder referral not ready, skipping', { network, codeStatus });
                 // Don't cache. A failed lookup (already logged) waits for the next
@@ -13050,10 +12480,7 @@ export class HyperLiquidProvider {
                 return;
             }
             // Check if user already has a referral on-chain
-            const hasReferral = await this.#checkReferralSet(userAddress);
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Referral account lookup');
-            }
+            const hasReferral = await this.#checkReferralSet();
             if (hasReferral) {
                 // Already has referral on-chain
                 PerpsSigningCache.setReferral(network, userAddress, {
@@ -13064,7 +12491,7 @@ export class HyperLiquidProvider {
             }
             else {
                 this.#deps.debugLogger.log('[ensureReferralSet] Setting referral (will show signing request)', { network, referralCode: expectedReferralCode });
-                const result = await this.#setReferralCode(accountContext);
+                const result = await this.#setReferralCode();
                 if (result) {
                     this.#deps.debugLogger.log('[ensureReferralSet] Referral set successfully', { network });
                     PerpsSigningCache.setReferral(network, userAddress, {
@@ -13092,11 +12519,6 @@ export class HyperLiquidProvider {
                 completeInFlight();
                 return;
             }
-            if (accountContext &&
-                this.#recordUnsupportedAccountFromError(error, accountContext)) {
-                completeInFlight();
-                return;
-            }
             // Safety net: wallet looked registered but the SDK still rejects with
             // "User or API Wallet 0x... does not exist." Do not forward to Sentry.
             // The walletRegistered cache stores positive observations only, so no
@@ -13106,12 +12528,6 @@ export class HyperLiquidProvider {
                 completeInFlight();
                 return;
             }
-            if (accountContext &&
-                ensureError(error, 'HyperLiquidProvider.ensureReferralSet').message ===
-                    PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
-                completeInFlight();
-                throw error;
-            }
             // Cache failure to prevent retries
             PerpsSigningCache.setReferral(network, userAddress, {
                 attempted: true,
@@ -13169,20 +12585,18 @@ export class HyperLiquidProvider {
     /**
      * Check if user has a referral code set with HyperLiquid
      *
-     * @param userAddress - Account to inspect, or the currently selected account
-     * when omitted.
      * @returns Promise resolving to true if referral is set, false otherwise
      */
-    async #checkReferralSet(userAddress) {
+    async #checkReferralSet() {
         try {
             const infoClient = this.#clientService.getInfoClient();
-            const referralUserAddress = userAddress ?? (await this.#walletService.getUserAddressWithDefault());
+            const userAddress = await this.#walletService.getUserAddressWithDefault();
             // Call HyperLiquid API to check if user has a referral set
             const referralData = await infoClient.referral({
-                user: referralUserAddress,
+                user: userAddress,
             });
             this.#deps.debugLogger.log('Referral check result:', {
-                userAddress: referralUserAddress,
+                userAddress,
                 referralData,
             });
             return Boolean(referralData?.referredBy?.code);
@@ -13206,15 +12620,10 @@ export class HyperLiquidProvider {
     /**
      * Set MetaMask as the user's referrer on HyperLiquid
      *
-     * @param accountContext - Account/network/lifecycle captured by the action
-     * that is allowed to authorize this write.
      * @returns A promise that resolves to the boolean result.
      */
-    async #setReferralCode(accountContext) {
+    async #setReferralCode() {
         try {
-            if (accountContext) {
-                await this.#assertNoKnownUnsupportedAccount(accountContext, 'Referral setup');
-            }
             const exchangeClient = this.#clientService.getExchangeClient();
             const referralCode = this.#getReferralCode(this.#clientService.isTestnetMode());
             this.#deps.debugLogger.log('[setReferralCode] Setting referral code', {
@@ -13226,18 +12635,9 @@ export class HyperLiquidProvider {
                 code: referralCode,
             });
             this.#deps.debugLogger.log('[setReferralCode] Referral code set result', result);
-            if (result?.status !== 'ok' &&
-                accountContext &&
-                this.#recordUnsupportedAccountFromError(new Error(`Referral setup failed: ${JSON.stringify(result)}`), accountContext)) {
-                return false;
-            }
             return result?.status === 'ok';
         }
         catch (error) {
-            if (accountContext &&
-                this.#recordUnsupportedAccountFromError(error, accountContext)) {
-                throw error;
-            }
             // Retryable (a locked keyring, an unavailable agent, or one the venue
             // rejected): `#ensureReferralSet` retries at the next entry, so it is
             // not an error to report.