@deeeed/metamask-harness 0.94.4 → 0.94.5

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.94.5 - 2026-10-28
+
+### Fixed
+
+- Extension readiness uses the registered EVM background action and preserves its result when the optional Perps read times out, keeping genuine RPC failures fatal.
+
 ## 0.94.4 - 2026-10-27
 
 ### Changed

package/dist/adapters/extension/runtime.js

@@ -328,7 +328,7 @@ async function boundedCdpCall(session, method, params, timeoutMs) {
 async function evaluateHealth(session, timeoutMs) {
   const backgroundProbeTimeoutMs = extensionBackgroundProbeTimeoutMs(timeoutMs);
   const result = await boundedCdpCall(session, "Runtime.evaluate", {
-    expression: `(() => {
+    expression: `(async () => {
       const hooks = globalThis.stateHooks || {};
       const bodyText = document.body?.innerText || '';
       const storeState = hooks.store?.getState?.() || {};
@@ -336,78 +336,80 @@ async function evaluateHealth(session, timeoutMs) {
       const accountCache = manager?.account?.cache;
       const networkConnectionBanner = storeState.metamask?.networkConnectionBanner;
       const networkClientId = storeState.metamask?.selectedNetworkClientId || networkConnectionBanner?.networkClientId;
-      return Promise.race([
-        (async () => {
-          const [backgroundProbe, evmRpcProbe] = await Promise.all([
-            (async () => {
-              if (typeof hooks.submitRequestToBackground !== 'function') {
-                return { ok: false, error: 'submitRequestToBackground is not a function' };
-              }
-              try {
-                const accountState = await hooks.submitRequestToBackground('perpsGetAccountState', []);
-                const ok = Boolean(accountState && typeof accountState === 'object');
-                return { ok, error: ok ? null : 'perpsGetAccountState returned an empty result' };
-              } catch (error) {
-                return { ok: false, error: String(error?.message || error) };
-              }
-            })(),
-            (async () => {
-              if (typeof hooks.submitRequestToBackground !== 'function') {
-                return { ok: false, error: 'submitRequestToBackground is not a function' };
-              }
-              if (typeof networkClientId !== 'string' || networkClientId.length === 0) {
-                return { ok: false, error: 'selected EVM network client is unavailable' };
-              }
-              try {
-                const code = await hooks.submitRequestToBackground('getCode', [
-                  '0x0000000000000000000000000000000000000000',
-                  networkClientId,
-                ]);
-                const ok = typeof code === 'string' && code.startsWith('0x');
-                return { ok, error: ok ? null : 'background EVM RPC returned an invalid result' };
-              } catch (error) {
-                return { ok: false, error: String(error?.message || error) };
-              }
-            })(),
+      async function withDeadline(read, error) {
+        let timer;
+        try {
+          return await Promise.race([
+            read,
+            new Promise((resolve) => {
+              timer = setTimeout(() => resolve({ ok: false, error }), ${backgroundProbeTimeoutMs});
+            }),
           ]);
-          return {
-            href: location.href,
-            title: document.title,
-            hasPageContent: bodyText.trim().length > 0,
-            hookKeys: Object.keys(hooks),
-            hasSubmitRequest: typeof hooks.submitRequestToBackground === 'function',
-            hasStore: Boolean(hooks.store),
-            hasPerpsStreamManager: typeof hooks.getPerpsStreamManager === 'function',
-            backgroundUnresponsive: bodyText.includes('Background connection unresponsive') || bodyText.includes('MetaMask had trouble starting'),
-            ethereumConnectionUnavailable: bodyText.includes('Unable to connect to Ethereum'),
-            activeProvider: storeState.metamask?.activeProvider || null,
-            isTestnet: Boolean(storeState.metamask?.isTestnet),
-            perpsManagerInitialized: Boolean(manager?.isInitialized?.()),
-            positionsCacheIsArray: Array.isArray(manager?.positions?.cache),
-            ordersCacheIsArray: Array.isArray(manager?.orders?.cache),
-            accountCachePresent: Boolean(accountCache && typeof accountCache === 'object'),
-            backgroundProbeOk: backgroundProbe.ok,
-            backgroundProbeError: backgroundProbe.error,
-            evmRpcProbeOk: evmRpcProbe.ok,
-            evmRpcProbeError: evmRpcProbe.error,
-          };
-        })(),
-        new Promise((resolve) => setTimeout(() => resolve({
-          href: location.href,
-          title: document.title,
-          hasPageContent: bodyText.trim().length > 0,
-          hookKeys: Object.keys(hooks),
-          hasSubmitRequest: typeof hooks.submitRequestToBackground === 'function',
-          hasStore: Boolean(hooks.store),
-          hasPerpsStreamManager: typeof hooks.getPerpsStreamManager === 'function',
-          backgroundUnresponsive: bodyText.includes('Background connection unresponsive') || bodyText.includes('MetaMask had trouble starting'),
-          ethereumConnectionUnavailable: bodyText.includes('Unable to connect to Ethereum'),
-          backgroundProbeOk: false,
-          backgroundProbeError: 'perpsGetAccountState timed out after ${backgroundProbeTimeoutMs}ms',
-          evmRpcProbeOk: false,
-          evmRpcProbeError: 'background EVM RPC timed out after ${backgroundProbeTimeoutMs}ms',
-        }), ${backgroundProbeTimeoutMs})),
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      const [backgroundProbe, evmRpcProbe] = await Promise.all([
+        withDeadline((async () => {
+          if (typeof hooks.submitRequestToBackground !== 'function') {
+            return { ok: false, error: 'submitRequestToBackground is not a function' };
+          }
+          try {
+            const accountState = await hooks.submitRequestToBackground('perpsGetAccountState', []);
+            const ok = Boolean(accountState && typeof accountState === 'object');
+            return { ok, error: ok ? null : 'perpsGetAccountState returned an empty result' };
+          } catch (error) {
+            return { ok: false, error: String(error?.message || error) };
+          }
+        })(), 'perpsGetAccountState timed out after ${backgroundProbeTimeoutMs}ms'),
+        withDeadline((async () => {
+          if (typeof hooks.submitRequestToBackground !== 'function') {
+            return { ok: false, error: 'submitRequestToBackground is not a function' };
+          }
+          if (typeof networkClientId !== 'string' || networkClientId.length === 0) {
+            return { ok: false, error: 'selected EVM network client is unavailable' };
+          }
+          try {
+            const args = ['0x0000000000000000000000000000000000000000', networkClientId];
+            let code;
+            try {
+              code = await hooks.submitRequestToBackground('messengerCall', ['LegacyBackgroundApiService:getCode', args]);
+            } catch (error) {
+              // Older builds may lack the messenger API or its EVM action.
+              const message = String(error?.message || error);
+              const missingApi = error?.code === -32601 && message === 'messengerCall not found';
+              const missingAction = message.includes('A handler for LegacyBackgroundApiService:getCode has not been registered');
+              if (!missingApi && !missingAction) throw error;
+              code = await hooks.submitRequestToBackground('getCode', args);
+            }
+            const ok = typeof code === 'string' && code.startsWith('0x');
+            return { ok, error: ok ? null : 'background EVM RPC returned an invalid result' };
+          } catch (error) {
+            return { ok: false, error: String(error?.message || error) };
+          }
+        })(), 'background EVM RPC timed out after ${backgroundProbeTimeoutMs}ms'),
       ]);
+      return {
+        href: location.href,
+        title: document.title,
+        hasPageContent: bodyText.trim().length > 0,
+        hookKeys: Object.keys(hooks),
+        hasSubmitRequest: typeof hooks.submitRequestToBackground === 'function',
+        hasStore: Boolean(hooks.store),
+        hasPerpsStreamManager: typeof hooks.getPerpsStreamManager === 'function',
+        backgroundUnresponsive: bodyText.includes('Background connection unresponsive') || bodyText.includes('MetaMask had trouble starting'),
+        ethereumConnectionUnavailable: bodyText.includes('Unable to connect to Ethereum'),
+        activeProvider: storeState.metamask?.activeProvider || null,
+        isTestnet: Boolean(storeState.metamask?.isTestnet),
+        perpsManagerInitialized: Boolean(manager?.isInitialized?.()),
+        positionsCacheIsArray: Array.isArray(manager?.positions?.cache),
+        ordersCacheIsArray: Array.isArray(manager?.orders?.cache),
+        accountCachePresent: Boolean(accountCache && typeof accountCache === 'object'),
+        backgroundProbeOk: backgroundProbe.ok,
+        backgroundProbeError: backgroundProbe.error,
+        evmRpcProbeOk: evmRpcProbe.ok,
+        evmRpcProbeError: evmRpcProbe.error,
+      };
     })()`,
     awaitPromise: true,
     returnByValue: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.94.4",
+  "version": "0.94.5",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"