@naculus/connect-appkit-vue 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -78,6 +78,7 @@ __export(index_exports, {
   useExecuteRoute: () => useExecuteRoute,
   useLastTx: () => useLastTx,
   useLookupAddress: () => useLookupAddress,
+  useMppSession: () => useMppSession,
   useNotification: () => useNotification,
   usePassphraseGate: () => usePassphraseGate,
   usePaymentFetch: () => usePaymentFetch,
@@ -341,9 +342,19 @@ function useNotification(options = {}) {
     () => notifications.value.filter((item) => !item.read).length
   );
   let disposed = false;
-  void (0, import_connect_appkit_core.loadNotificationSettings)(storage).then((saved) => {
-    if (!disposed && saved) settings.value = saved;
-  });
+  let pending = [];
+  const settle = (saved) => {
+    const queued = pending ?? [];
+    pending = null;
+    if (disposed) return;
+    if (queued.length === 0) {
+      if (saved) settings.value = saved;
+      return;
+    }
+    settings.value = (0, import_connect_appkit_core.replayNotificationSettings)(saved, queued);
+    (0, import_connect_appkit_core.saveNotificationSettings)(storage, settings.value);
+  };
+  void (0, import_connect_appkit_core.loadNotificationSettings)(storage).then(settle, () => settle(null));
   channel.onNotification = (item) => {
     if (!disposed) notifications.value = [...notifications.value, item];
   };
@@ -354,10 +365,15 @@ function useNotification(options = {}) {
     disposed = true;
     channel.onNotification = void 0;
   });
-  const updateSettings = (update) => {
-    settings.value = (0, import_connect_appkit_core.updateNotificationSettings)(settings.value, update);
+  const applySettings = (compute) => {
+    pending?.push(compute);
+    settings.value = (0, import_connect_appkit_core.updateNotificationSettings)(
+      settings.value,
+      compute(settings.value)
+    );
     (0, import_connect_appkit_core.saveNotificationSettings)(storage, settings.value);
   };
+  const updateSettings = (update) => applySettings(() => update);
   return {
     notifications,
     unreadCount,
@@ -387,8 +403,8 @@ function useNotification(options = {}) {
     },
     updateSettings,
     setChannels: (channels) => updateSettings((0, import_connect_appkit_core.channelsUpdate)(channels)),
-    muteChain: (chainId) => updateSettings((0, import_connect_appkit_core.mutedChainSettings)(settings.value, chainId, true)),
-    unmuteChain: (chainId) => updateSettings((0, import_connect_appkit_core.mutedChainSettings)(settings.value, chainId, false))
+    muteChain: (chainId) => applySettings((current) => (0, import_connect_appkit_core.mutedChainSettings)(current, chainId, true)),
+    unmuteChain: (chainId) => applySettings((current) => (0, import_connect_appkit_core.mutedChainSettings)(current, chainId, false))
   };
 }
 
@@ -2617,16 +2633,143 @@ function usePaymentFetch(pay) {
   };
 }
 
-// src/useSolanaSessionKey.ts
+// src/useMppSession.ts
 var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
 var import_vue39 = require("vue");
+function useMppSession(session) {
+  const current = () => (0, import_vue39.unref)(session);
+  const pending = (0, import_vue39.shallowRef)(current().meter.pending);
+  const channel = (0, import_vue39.shallowRef)(
+    (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(current())
+  );
+  const lastReceipt = (0, import_vue39.shallowRef)(null);
+  const recoveryChannelId = (0, import_vue39.shallowRef)(null);
+  const isPending = (0, import_vue39.shallowRef)(false);
+  const error = (0, import_vue39.shallowRef)(null);
+  let active = 0;
+  let generation = 0;
+  let epoch = 0;
+  let disposed = false;
+  (0, import_vue39.watch)(
+    () => (0, import_vue39.unref)(session),
+    (value) => {
+      generation++;
+      epoch++;
+      active = 0;
+      isPending.value = false;
+      pending.value = value.meter.pending;
+      channel.value = (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(value);
+      lastReceipt.value = null;
+      recoveryChannelId.value = null;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  (0, import_vue39.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    epoch++;
+  });
+  const run = (operation, publish, clearsRecovery = false) => {
+    const own = ++generation;
+    const ownEpoch = epoch;
+    const invokedSession = current();
+    active++;
+    isPending.value = true;
+    error.value = null;
+    return operation(invokedSession).then((result) => {
+      if (!disposed && ownEpoch === epoch) {
+        publish?.(result);
+        const currentChannel = (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(invokedSession);
+        channel.value = currentChannel;
+        pending.value = invokedSession.meter.pending;
+        if (clearsRecovery || !currentChannel) {
+          recoveryChannelId.value = null;
+        }
+      }
+      return result;
+    }).catch((cause) => {
+      const normalized = cause instanceof Error ? cause : new Error("MPP session operation failed");
+      if (!disposed && ownEpoch === epoch) {
+        const currentChannel = (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(invokedSession);
+        channel.value = currentChannel;
+        pending.value = invokedSession.meter.pending;
+        const recovery = (0, import_connect_appkit_core25.readMppRecoveryChannelId)(cause);
+        if (recovery) recoveryChannelId.value = recovery;
+        else if (!currentChannel) recoveryChannelId.value = null;
+        if (own === generation) error.value = normalized;
+      }
+      throw normalized;
+    }).finally(() => {
+      if (ownEpoch === epoch) {
+        active--;
+        if (!disposed) isPending.value = active > 0;
+      }
+    });
+  };
+  const fetch = (input, init) => run(
+    (value) => value(input, init),
+    (result) => {
+      const receipt = (0, import_connect_appkit_core25.readMppSessionReceipt)(result.receipt);
+      if (receipt) lastReceipt.value = receipt;
+    }
+  );
+  const close = () => run(
+    (value) => value.close(),
+    (result) => {
+      const receipt = (0, import_connect_appkit_core25.readMppSessionReceipt)(result.receipt);
+      if (receipt) lastReceipt.value = receipt;
+    },
+    true
+  );
+  const forceClose = () => run((value) => value.forceClose(), void 0, true);
+  const add = (units) => {
+    try {
+      current().meter.add(units);
+      pending.value = current().meter.pending;
+      error.value = null;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("MPP session operation failed");
+      error.value = normalized;
+      recoveryChannelId.value = (0, import_connect_appkit_core25.readMppRecoveryChannelId)(cause);
+      throw normalized;
+    }
+  };
+  return {
+    fetch,
+    meter: { add },
+    pending,
+    channel,
+    lastReceipt,
+    recoveryChannelId,
+    isPending,
+    error,
+    close,
+    forceClose,
+    reset: () => {
+      generation++;
+      epoch++;
+      active = 0;
+      isPending.value = false;
+      pending.value = current().meter.pending;
+      channel.value = (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(current());
+      lastReceipt.value = null;
+      recoveryChannelId.value = null;
+      error.value = null;
+    }
+  };
+}
+
+// src/useSolanaSessionKey.ts
+var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
+var import_vue40 = require("vue");
 function useSolanaSessionKey(deps) {
   const guard = useActionGuard();
-  const keys = (0, import_vue39.shallowRef)([]);
+  const keys = (0, import_vue40.shallowRef)([]);
   let flow = null;
   let generation = 0;
   let disposed = false;
-  (0, import_vue39.onScopeDispose)(() => {
+  (0, import_vue40.onScopeDispose)(() => {
     disposed = true;
   });
   const refresh = async () => {
@@ -2634,10 +2777,10 @@ function useSolanaSessionKey(deps) {
     const next = flow ? await flow.list() : [];
     if (!disposed && own === generation) keys.value = next;
   };
-  (0, import_vue39.watch)(
-    () => (0, import_vue39.unref)(deps),
+  (0, import_vue40.watch)(
+    () => (0, import_vue40.unref)(deps),
     (next) => {
-      flow = next ? (0, import_connect_appkit_core25.createSolanaSessionKeyFlow)(next) : null;
+      flow = next ? (0, import_connect_appkit_core26.createSolanaSessionKeyFlow)(next) : null;
       guard.invalidate();
       void refresh().catch(() => {
       });
@@ -2668,17 +2811,17 @@ function useSolanaSessionKey(deps) {
 }
 
 // src/name-lookup.ts
-var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
-var import_vue40 = require("vue");
+var import_connect_appkit_core27 = require("@naculus/connect-appkit-core");
+var import_vue41 = require("vue");
 function useNameLookup(options) {
   const guard = useActionGuard();
-  const data = (0, import_vue40.shallowRef)(null);
-  const loading = (0, import_vue40.shallowRef)(false);
+  const data = (0, import_vue41.shallowRef)(null);
+  const loading = (0, import_vue41.shallowRef)(false);
   const run = () => {
-    const input = (0, import_vue40.toValue)(options.input).trim();
-    const skip = (0, import_vue40.toValue)(options.skip) ?? false;
-    const scope = (0, import_vue40.toValue)(options.scope);
-    const config = (0, import_vue40.toValue)(options.resolverConfig);
+    const input = (0, import_vue41.toValue)(options.input).trim();
+    const skip = (0, import_vue41.toValue)(options.skip) ?? false;
+    const scope = (0, import_vue41.toValue)(options.scope);
+    const config = (0, import_vue41.toValue)(options.resolverConfig);
     if (!input || skip) {
       guard.reset();
       data.value = null;
@@ -2691,7 +2834,7 @@ function useNameLookup(options) {
       async (commit) => {
         try {
           const result = await Promise.resolve().then(
-            () => options.query((0, import_connect_appkit_core26.getResolver)(config), input, scope)
+            () => options.query((0, import_connect_appkit_core27.getResolver)(config), input, scope)
           );
           commit(() => {
             data.value = result;
@@ -2713,19 +2856,19 @@ function useNameLookup(options) {
     ).catch(() => {
     });
   };
-  (0, import_vue40.watch)(
+  (0, import_vue41.watch)(
     () => [
-      (0, import_vue40.toValue)(options.input),
-      (0, import_vue40.toValue)(options.skip),
-      (0, import_vue40.toValue)(options.scope),
-      (0, import_vue40.toValue)(options.resolverConfig)
+      (0, import_vue41.toValue)(options.input),
+      (0, import_vue41.toValue)(options.skip),
+      (0, import_vue41.toValue)(options.scope),
+      (0, import_vue41.toValue)(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
   return {
     data,
-    isLoading: (0, import_vue40.computed)(() => loading.value),
+    isLoading: (0, import_vue41.computed)(() => loading.value),
     error: guard.error,
     refetch: run
   };
@@ -2753,21 +2896,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-var import_vue41 = require("vue");
+var import_vue42 = require("vue");
 function useSolanaAccount(accounts, connected) {
-  const isConnected = (0, import_vue41.computed)(() => (0, import_vue41.toValue)(connected));
-  const caip10 = (0, import_vue41.computed)(
-    () => isConnected.value ? ((0, import_vue41.toValue)(accounts) ?? []).find(
+  const isConnected = (0, import_vue42.computed)(() => (0, import_vue42.toValue)(connected));
+  const caip10 = (0, import_vue42.computed)(
+    () => isConnected.value ? ((0, import_vue42.toValue)(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
-  const parts = (0, import_vue41.computed)(() => caip10.value?.split(":") ?? []);
+  const parts = (0, import_vue42.computed)(() => caip10.value?.split(":") ?? []);
   return {
-    address: (0, import_vue41.computed)(
+    address: (0, import_vue42.computed)(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: (0, import_vue41.computed)(
+    chainId: (0, import_vue42.computed)(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -2775,35 +2918,35 @@ function useSolanaAccount(accounts, connected) {
 }
 
 // src/useChain.ts
-var import_connect_appkit_core27 = require("@naculus/connect-appkit-core");
-var import_vue42 = require("vue");
+var import_connect_appkit_core28 = require("@naculus/connect-appkit-core");
+var import_vue43 = require("vue");
 function useChain(chains, chainId) {
-  const list = (0, import_vue42.computed)(() => (0, import_vue42.toValue)(chains) ?? []);
-  const id = (0, import_vue42.computed)(() => (0, import_vue42.toValue)(chainId) ?? null);
-  const currentChain = (0, import_vue42.computed)(() => (0, import_connect_appkit_core27.resolveChain)(list.value, id.value));
+  const list = (0, import_vue43.computed)(() => (0, import_vue43.toValue)(chains) ?? []);
+  const id = (0, import_vue43.computed)(() => (0, import_vue43.toValue)(chainId) ?? null);
+  const currentChain = (0, import_vue43.computed)(() => (0, import_connect_appkit_core28.resolveChain)(list.value, id.value));
   return {
     currentChain,
-    chainInfo: (0, import_vue42.computed)(() => (0, import_connect_appkit_core27.describeChain)(list.value, id.value)),
-    availableChains: (0, import_vue42.computed)(() => (0, import_connect_appkit_core27.chainsForNamespace)(list.value, id.value)),
-    currentChainNumber: (0, import_vue42.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core27.chainNumber)(currentChain.value) : null
+    chainInfo: (0, import_vue43.computed)(() => (0, import_connect_appkit_core28.describeChain)(list.value, id.value)),
+    availableChains: (0, import_vue43.computed)(() => (0, import_connect_appkit_core28.chainsForNamespace)(list.value, id.value)),
+    currentChainNumber: (0, import_vue43.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core28.chainNumber)(currentChain.value) : null
     ),
-    namespace: (0, import_vue42.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core27.chainNamespace)(currentChain.value) : null
+    namespace: (0, import_vue43.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core28.chainNamespace)(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-var import_vue43 = require("vue");
+var import_vue44 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue43.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue44.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue43.onScopeDispose)(unsubscribe);
+  (0, import_vue44.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue43.readonly)(request),
+    request: (0, import_vue44.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -2812,14 +2955,14 @@ function usePassphraseGate(gate) {
 
 // src/useSolanaBalance.ts
 var import_connect_core17 = require("@naculus/connect-core");
-var import_vue44 = require("vue");
+var import_vue45 = require("vue");
 function useSolanaBalance(address, rpcUrl) {
   const guard = useActionGuard();
-  const balance = (0, import_vue44.shallowRef)(null);
-  const isFetching = (0, import_vue44.ref)(false);
+  const balance = (0, import_vue45.shallowRef)(null);
+  const isFetching = (0, import_vue45.ref)(false);
   const refetch = async () => {
-    const addr = (0, import_vue44.toValue)(address);
-    const url = (0, import_vue44.toValue)(rpcUrl);
+    const addr = (0, import_vue45.toValue)(address);
+    const url = (0, import_vue45.toValue)(rpcUrl);
     if (!addr || !url) {
       guard.invalidate();
       isFetching.value = false;
@@ -2851,22 +2994,22 @@ function useSolanaBalance(address, rpcUrl) {
     ).catch(() => {
     });
   };
-  (0, import_vue44.watchEffect)(() => {
-    (0, import_vue44.toValue)(address);
-    (0, import_vue44.toValue)(rpcUrl);
+  (0, import_vue45.watchEffect)(() => {
+    (0, import_vue45.toValue)(address);
+    (0, import_vue45.toValue)(rpcUrl);
     void refetch();
   });
   return { balance, isFetching, error: guard.error, refetch };
 }
 
 // src/useLastTx.ts
-var import_vue45 = require("vue");
+var import_vue46 = require("vue");
 function useLastTx(monitor) {
-  const lastTx = (0, import_vue45.shallowRef)(null);
-  const lastConfirmedTx = (0, import_vue45.shallowRef)(null);
-  const lastFailedTx = (0, import_vue45.shallowRef)(null);
-  (0, import_vue45.watch)(
-    () => (0, import_vue45.toValue)(monitor),
+  const lastTx = (0, import_vue46.shallowRef)(null);
+  const lastConfirmedTx = (0, import_vue46.shallowRef)(null);
+  const lastFailedTx = (0, import_vue46.shallowRef)(null);
+  (0, import_vue46.watch)(
+    () => (0, import_vue46.toValue)(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -2904,13 +3047,13 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-var import_vue46 = require("vue");
+var import_vue47 = require("vue");
 function useTxHistory(address, chainId, monitor) {
   const guard = useActionGuard();
-  const entries = (0, import_vue46.shallowRef)([]);
-  const isLoading = (0, import_vue46.shallowRef)(false);
+  const entries = (0, import_vue47.shallowRef)([]);
+  const isLoading = (0, import_vue47.shallowRef)(false);
   const refresh = async () => {
-    const activeMonitor = (0, import_vue46.toValue)(monitor);
+    const activeMonitor = (0, import_vue47.toValue)(monitor);
     if (!activeMonitor) {
       guard.reset();
       entries.value = [];
@@ -2921,8 +3064,8 @@ function useTxHistory(address, chainId, monitor) {
     await guard.run(
       async (commit) => {
         const result = await activeMonitor.getTxHistory(
-          (0, import_vue46.toValue)(address) ?? void 0,
-          (0, import_vue46.toValue)(chainId) ?? void 0
+          (0, import_vue47.toValue)(address) ?? void 0,
+          (0, import_vue47.toValue)(chainId) ?? void 0
         );
         commit(() => {
           entries.value = result;
@@ -2938,8 +3081,8 @@ function useTxHistory(address, chainId, monitor) {
     ).catch(() => {
     });
   };
-  (0, import_vue46.watch)(
-    [() => (0, import_vue46.toValue)(monitor), () => (0, import_vue46.toValue)(address), () => (0, import_vue46.toValue)(chainId)],
+  (0, import_vue47.watch)(
+    [() => (0, import_vue47.toValue)(monitor), () => (0, import_vue47.toValue)(address), () => (0, import_vue47.toValue)(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -2959,7 +3102,7 @@ function useTxHistory(address, chainId, monitor) {
     isLoading,
     error: guard.error,
     refresh,
-    summary: (0, import_vue46.computed)(() => ({
+    summary: (0, import_vue47.computed)(() => ({
       pending: entries.value.filter((item) => item.status === "pending").length,
       confirmed: entries.value.filter((item) => item.status === "confirmed").length,
       failed: entries.value.filter((item) => item.status === "failed").length
@@ -2968,45 +3111,74 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-var import_vue47 = require("vue");
+var import_vue48 = require("vue");
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = (0, import_vue47.shallowRef)(null);
-  const isLoading = (0, import_vue47.shallowRef)(false);
-  const isWatching = (0, import_vue47.shallowRef)(false);
-  const error = (0, import_vue47.shallowRef)(null);
+  const entry = (0, import_vue48.shallowRef)(null);
+  const isLoading = (0, import_vue48.shallowRef)(false);
+  const isWatching = (0, import_vue48.shallowRef)(false);
+  const guard = useActionGuard();
+  const error = guard.error;
   let generation = 0;
+  let refreshed = [];
+  const currentInputs = () => [
+    (0, import_vue48.toValue)(monitor),
+    (0, import_vue48.toValue)(hash),
+    (0, import_vue48.toValue)(chainId)
+  ];
+  const sameInputs = (a, b) => a.every((value, i) => Object.is(value, b[i]));
   const refresh = async () => {
-    const activeMonitor = (0, import_vue47.toValue)(monitor);
-    const activeHash = (0, import_vue47.toValue)(hash);
-    const activeChainId = (0, import_vue47.toValue)(chainId);
+    const activeMonitor = (0, import_vue48.toValue)(monitor);
+    const activeHash = (0, import_vue48.toValue)(hash);
+    const activeChainId = (0, import_vue48.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
+    const started = [activeMonitor, activeHash, activeChainId];
+    refreshed = started;
     isLoading.value = true;
-    error.value = null;
-    try {
-      await activeMonitor.refreshTx(activeHash, activeChainId ?? void 0);
-      const current = activeMonitor.getTxStatus(
-        activeHash,
-        activeChainId ?? void 0
-      );
-      if (current) entry.value = current;
-    } catch (err) {
-      error.value = err instanceof Error ? err : new Error("Failed to refresh transaction");
-    } finally {
-      isLoading.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          await activeMonitor.refreshTx(
+            activeHash,
+            activeChainId ?? void 0
+          );
+        } catch (err) {
+          if (!sameInputs(started, currentInputs())) return;
+          throw err;
+        }
+        if (!sameInputs(started, currentInputs())) return;
+        const current = activeMonitor.getTxStatus(
+          activeHash,
+          activeChainId ?? void 0
+        );
+        commit(() => {
+          entry.value = current ?? null;
+        });
+      },
+      "Failed to refresh transaction",
+      void 0,
+      {
+        onSettled: () => {
+          isLoading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   const stopWatching = () => {
-    const activeMonitor = (0, import_vue47.toValue)(monitor);
-    const activeHash = (0, import_vue47.toValue)(hash);
-    const activeChainId = (0, import_vue47.toValue)(chainId);
+    const activeMonitor = (0, import_vue48.toValue)(monitor);
+    const activeHash = (0, import_vue48.toValue)(hash);
+    const activeChainId = (0, import_vue48.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  (0, import_vue47.watch)(
-    [() => (0, import_vue47.toValue)(monitor), () => (0, import_vue47.toValue)(hash), () => (0, import_vue47.toValue)(chainId)],
+  (0, import_vue48.watch)(
+    [() => (0, import_vue48.toValue)(monitor), () => (0, import_vue48.toValue)(hash), () => (0, import_vue48.toValue)(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
+      if (!sameInputs([activeMonitor, activeHash, activeChainId], refreshed)) {
+        guard.invalidate();
+      }
       if (!activeMonitor || !activeHash || !activeChainId) {
         entry.value = null;
         isLoading.value = false;
@@ -3028,8 +3200,7 @@ function useTxMonitor(hash, chainId, monitor) {
       isWatching.value = true;
       isLoading.value = true;
       error.value = null;
-      const current = activeMonitor.getTxStatus(activeHash, activeChainId);
-      if (current) entry.value = current;
+      entry.value = activeMonitor.getTxStatus(activeHash, activeChainId) ?? null;
       activeMonitor.watchTx(activeHash, activeChainId, {}).then((initial) => {
         if (cancelled || mine !== generation) return;
         entry.value = initial;
@@ -3044,7 +3215,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: (0, import_vue47.computed)(() => entry.value?.status ?? "idle"),
+    status: (0, import_vue48.computed)(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -3054,17 +3225,17 @@ function useTxMonitor(hash, chainId, monitor) {
 }
 
 // src/useCapabilities.ts
-var import_connect_appkit_core28 = require("@naculus/connect-appkit-core");
-var import_vue48 = require("vue");
+var import_connect_appkit_core29 = require("@naculus/connect-appkit-core");
+var import_vue49 = require("vue");
 function useCapabilities(client, session, chainId) {
   const guard = useActionGuard();
-  const capabilities = (0, import_vue48.shallowRef)(
+  const capabilities = (0, import_vue49.shallowRef)(
     null
   );
-  const isFetching = (0, import_vue48.shallowRef)(false);
+  const isFetching = (0, import_vue49.shallowRef)(false);
   const refetch = async () => {
-    const activeClient = (0, import_vue48.toValue)(client);
-    const activeSession = (0, import_vue48.toValue)(session);
+    const activeClient = (0, import_vue49.toValue)(client);
+    const activeSession = (0, import_vue49.toValue)(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       guard.reset();
       capabilities.value = null;
@@ -3077,7 +3248,7 @@ function useCapabilities(client, session, chainId) {
         try {
           const raw = await activeClient.getCapabilities(activeSession);
           commit(() => {
-            capabilities.value = (0, import_connect_appkit_core28.normalizeCapabilities)(raw);
+            capabilities.value = (0, import_connect_appkit_core29.normalizeCapabilities)(raw);
           });
         } catch (err) {
           commit(() => {
@@ -3096,18 +3267,18 @@ function useCapabilities(client, session, chainId) {
     ).catch(() => {
     });
   };
-  (0, import_vue48.watchEffect)(() => {
-    void (0, import_vue48.toValue)(client);
-    void (0, import_vue48.toValue)(session);
+  (0, import_vue49.watchEffect)(() => {
+    void (0, import_vue49.toValue)(client);
+    void (0, import_vue49.toValue)(session);
     void refetch();
   });
   return {
     capabilities,
-    current: (0, import_vue48.computed)(
-      () => (0, import_connect_appkit_core28.selectChainCapabilities)(capabilities.value, (0, import_vue48.toValue)(chainId))
+    current: (0, import_vue49.computed)(
+      () => (0, import_connect_appkit_core29.selectChainCapabilities)(capabilities.value, (0, import_vue49.toValue)(chainId))
     ),
-    atomic: (0, import_vue48.computed)(
-      () => (0, import_connect_appkit_core28.atomicSupportFor)(capabilities.value, (0, import_vue48.toValue)(chainId))
+    atomic: (0, import_vue49.computed)(
+      () => (0, import_connect_appkit_core29.atomicSupportFor)(capabilities.value, (0, import_vue49.toValue)(chainId))
     ),
     isFetching,
     error: guard.error,
@@ -3116,18 +3287,18 @@ function useCapabilities(client, session, chainId) {
 }
 
 // src/useSolanaRoles.ts
-var import_connect_appkit_core29 = require("@naculus/connect-appkit-core");
-var import_vue49 = require("vue");
+var import_connect_appkit_core30 = require("@naculus/connect-appkit-core");
+var import_vue50 = require("vue");
 function useSolanaRoles(connector, session) {
-  const state = (0, import_vue49.computed)(
-    () => (0, import_connect_appkit_core29.readSolanaRoles)((0, import_vue49.toValue)(connector), (0, import_vue49.toValue)(session))
+  const state = (0, import_vue50.computed)(
+    () => (0, import_connect_appkit_core30.readSolanaRoles)((0, import_vue50.toValue)(connector), (0, import_vue50.toValue)(session))
   );
   return {
-    roles: (0, import_vue49.computed)(() => state.value.roles),
-    absence: (0, import_vue49.computed)(() => state.value.absence),
-    identity: (0, import_vue49.computed)(() => state.value.roles?.identity ?? null),
-    signer: (0, import_vue49.computed)(() => state.value.roles?.signer ?? null),
-    payer: (0, import_vue49.computed)(() => state.value.roles?.payer ?? null)
+    roles: (0, import_vue50.computed)(() => state.value.roles),
+    absence: (0, import_vue50.computed)(() => state.value.absence),
+    identity: (0, import_vue50.computed)(() => state.value.roles?.identity ?? null),
+    signer: (0, import_vue50.computed)(() => state.value.roles?.signer ?? null),
+    payer: (0, import_vue50.computed)(() => state.value.roles?.payer ?? null)
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3180,6 +3351,7 @@ function useSolanaRoles(connector, session) {
   useExecuteRoute,
   useLastTx,
   useLookupAddress,
+  useMppSession,
   useNotification,
   usePassphraseGate,
   usePaymentFetch,