@naculus/connect-appkit-vue 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -60,6 +60,7 @@ __export(index_exports, {
   AppkitTooltip: () => AppkitTooltip,
   useAccount: () => useAccount,
   useAccounts: () => useAccounts,
+  useAuthorizations: () => useAuthorizations,
   useBalance: () => useBalance,
   useCapabilities: () => useCapabilities,
   useChain: () => useChain,
@@ -78,6 +79,7 @@ __export(index_exports, {
   useExecuteRoute: () => useExecuteRoute,
   useLastTx: () => useLastTx,
   useLookupAddress: () => useLookupAddress,
+  useMppSession: () => useMppSession,
   useNotification: () => useNotification,
   usePassphraseGate: () => usePassphraseGate,
   usePaymentFetch: () => usePaymentFetch,
@@ -326,38 +328,99 @@ function useAccounts(accounts) {
   };
 }
 
-// src/useNotification.ts
-var import_connect_appkit_core = require("@naculus/connect-appkit-core");
+// src/useAuthorizations.ts
 var import_connect_core2 = require("@naculus/connect-core");
 var import_vue2 = require("vue");
+function useAuthorizations({
+  managers
+}) {
+  const entries = (0, import_vue2.shallowRef)([]);
+  const loading = (0, import_vue2.shallowRef)(false);
+  const error = (0, import_vue2.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const refresh = async () => {
+    const own = ++generation;
+    loading.value = true;
+    error.value = null;
+    try {
+      const next = await (0, import_connect_core2.listAuthorizations)((0, import_vue2.unref)(managers));
+      if (!disposed && own === generation) entries.value = next;
+    } catch (cause) {
+      if (!disposed && own === generation) {
+        error.value = cause instanceof Error ? cause : new Error("Failed to list authorizations");
+      }
+    } finally {
+      if (!disposed && own === generation) loading.value = false;
+    }
+  };
+  const stop = (0, import_vue2.watch)(() => (0, import_vue2.unref)(managers), refresh, { immediate: true });
+  (0, import_vue2.onScopeDispose)(() => {
+    disposed = true;
+    generation += 1;
+    stop();
+  });
+  const revoke = async (entry) => {
+    try {
+      const result = await (0, import_connect_core2.revokeListedAuthorization)((0, import_vue2.unref)(managers), entry);
+      await refresh();
+      return result;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Failed to revoke authorization");
+      if (!disposed) error.value = normalized;
+      throw normalized;
+    }
+  };
+  return { entries, loading, error, refresh, revoke };
+}
+
+// src/useNotification.ts
+var import_connect_appkit_core = require("@naculus/connect-appkit-core");
+var import_connect_core3 = require("@naculus/connect-core");
+var import_vue3 = require("vue");
 function useNotification(options = {}) {
-  const channel = (0, import_vue2.unref)(options.channel) ?? new import_connect_core2.InAppChannel();
-  const storage = (0, import_vue2.unref)(options.storage) ?? (0, import_connect_appkit_core.createNotificationSettingsStorage)();
-  const notifications = (0, import_vue2.shallowRef)(channel.getHistory());
-  const settings = (0, import_vue2.shallowRef)(
+  const channel = (0, import_vue3.unref)(options.channel) ?? new import_connect_core3.InAppChannel();
+  const storage = (0, import_vue3.unref)(options.storage) ?? (0, import_connect_appkit_core.createNotificationSettingsStorage)();
+  const notifications = (0, import_vue3.shallowRef)(channel.getHistory());
+  const settings = (0, import_vue3.shallowRef)(
     import_connect_appkit_core.DEFAULT_NOTIFICATION_SETTINGS
   );
-  const unreadCount = (0, import_vue2.computed)(
+  const unreadCount = (0, import_vue3.computed)(
     () => 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];
   };
   void channel.restore().then(() => {
     if (!disposed) notifications.value = channel.getHistory();
   });
-  (0, import_vue2.onScopeDispose)(() => {
+  (0, import_vue3.onScopeDispose)(() => {
     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,21 +450,21 @@ 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))
   };
 }
 
 // src/useSimulateTransfer.ts
 var import_connect_appkit_core2 = require("@naculus/connect-appkit-core");
-var import_connect_core3 = require("@naculus/connect-core");
-var import_vue4 = require("vue");
+var import_connect_core4 = require("@naculus/connect-core");
+var import_vue5 = require("vue");
 
 // src/internal/action-guard.ts
-var import_vue3 = require("vue");
+var import_vue4 = require("vue");
 function useActionGuard() {
-  const busy = (0, import_vue3.shallowRef)(false);
-  const error = (0, import_vue3.shallowRef)(null);
+  const busy = (0, import_vue4.shallowRef)(false);
+  const error = (0, import_vue4.shallowRef)(null);
   let active = 0;
   let generation = 0;
   let disposed = false;
@@ -442,28 +505,28 @@ function useActionGuard() {
     disposed = true;
     generation++;
   };
-  (0, import_vue3.onScopeDispose)(dispose);
+  (0, import_vue4.onScopeDispose)(dispose);
   return { busy, error, run, clearError, reset, invalidate, dispose };
 }
 
 // src/useSimulateTransfer.ts
 function useSimulateTransfer(options = {}) {
   const guard = useActionGuard();
-  const result = (0, import_vue4.shallowRef)(null);
-  const loading = (0, import_vue4.shallowRef)(false);
+  const result = (0, import_vue5.shallowRef)(null);
+  const loading = (0, import_vue5.shallowRef)(false);
   let manager;
   const simulate = async (tokenAddress, from, to, amount, callOptions) => {
     loading.value = true;
     return await guard.run(
       async (commit) => {
-        const fallbackRpcUrl = (0, import_vue4.unref)(options.rpcUrl);
+        const fallbackRpcUrl = (0, import_vue5.unref)(options.rpcUrl);
         const endpoint = (0, import_connect_appkit_core2.resolveSimulationEndpoint)(
           callOptions?.chainId,
-          (0, import_vue4.unref)(options.chainId),
+          (0, import_vue5.unref)(options.chainId),
           callOptions?.rpcUrl,
           fallbackRpcUrl
         );
-        manager ??= new import_connect_core3.SimulationManager({
+        manager ??= new import_connect_core4.SimulationManager({
           enabled: true,
           rpcUrl: fallbackRpcUrl,
           autoSimulate: false
@@ -501,22 +564,22 @@ function useSimulateTransfer(options = {}) {
 
 // src/useTransactionSimulation.ts
 var import_connect_appkit_core3 = require("@naculus/connect-appkit-core");
-var import_vue5 = require("vue");
+var import_vue6 = require("vue");
 function useTransactionSimulation(tx, options = {}) {
   const guard = useActionGuard();
-  const result = (0, import_vue5.shallowRef)(void 0);
-  const isSimulating = (0, import_vue5.shallowRef)(false);
+  const result = (0, import_vue6.shallowRef)(void 0);
+  const isSimulating = (0, import_vue6.shallowRef)(false);
   let timer;
   const simulate = async () => {
-    const transaction = (0, import_vue5.toValue)(tx);
+    const transaction = (0, import_vue6.toValue)(tx);
     if (transaction) isSimulating.value = true;
     return await guard.run(
       async (commit) => {
         const value = await (0, import_connect_appkit_core3.simulateTransactionPreview)(transaction, {
-          chainId: (0, import_vue5.unref)(options.chainId),
-          currentChain: (0, import_vue5.unref)(options.currentChain),
-          publicClient: (0, import_vue5.unref)(options.publicClient),
-          evmAccount: (0, import_vue5.unref)(options.evmAccount)
+          chainId: (0, import_vue6.unref)(options.chainId),
+          currentChain: (0, import_vue6.unref)(options.currentChain),
+          publicClient: (0, import_vue6.unref)(options.publicClient),
+          evmAccount: (0, import_vue6.unref)(options.evmAccount)
         });
         commit(() => {
           result.value = value;
@@ -533,13 +596,13 @@ function useTransactionSimulation(tx, options = {}) {
       }
     );
   };
-  (0, import_vue5.watch)(
+  (0, import_vue6.watch)(
     [
-      () => (0, import_vue5.toValue)(tx),
-      () => (0, import_vue5.unref)(options.chainId),
-      () => (0, import_vue5.unref)(options.currentChain),
-      () => (0, import_vue5.unref)(options.publicClient),
-      () => (0, import_vue5.unref)(options.evmAccount)
+      () => (0, import_vue6.toValue)(tx),
+      () => (0, import_vue6.unref)(options.chainId),
+      () => (0, import_vue6.unref)(options.currentChain),
+      () => (0, import_vue6.unref)(options.publicClient),
+      () => (0, import_vue6.unref)(options.evmAccount)
     ],
     ([transaction]) => {
       guard.invalidate();
@@ -561,7 +624,7 @@ function useTransactionSimulation(tx, options = {}) {
     result.value = void 0;
     isSimulating.value = false;
   };
-  (0, import_vue5.onScopeDispose)(() => {
+  (0, import_vue6.onScopeDispose)(() => {
     if (timer) clearTimeout(timer);
   });
   return { result, isSimulating, error: guard.error, simulate, reset };
@@ -569,43 +632,43 @@ function useTransactionSimulation(tx, options = {}) {
 
 // src/useERC20Transfer.ts
 var import_connect_appkit_core5 = require("@naculus/connect-appkit-core");
-var import_connect_core5 = require("@naculus/connect-core");
-var import_vue6 = require("vue");
+var import_connect_core6 = require("@naculus/connect-core");
+var import_vue7 = require("vue");
 
 // src/erc20.ts
 var import_connect_appkit_core4 = require("@naculus/connect-appkit-core");
-var import_connect_core4 = require("@naculus/connect-core");
+var import_connect_core5 = require("@naculus/connect-core");
 function assertErc20Context(token, chainId, account, connected) {
   if (!connected || !account) {
-    throw new import_connect_core4.WalletError("wallet_unavailable", "No connected account");
+    throw new import_connect_core5.WalletError("wallet_unavailable", "No connected account");
   }
   const mismatch = (0, import_connect_appkit_core4.tokenChainMismatch)(token, chainId);
   if (mismatch) throw mismatch;
   const bare = (0, import_connect_appkit_core4.bareEvmAddress)(account);
   if (!bare) {
-    throw new import_connect_core4.WalletError("wallet_unavailable", "No valid EVM account");
+    throw new import_connect_core5.WalletError("wallet_unavailable", "No valid EVM account");
   }
   return bare;
 }
 
 // src/useERC20Transfer.ts
 function useERC20Transfer(options) {
-  const initialToken = (0, import_vue6.toValue)(options.token);
+  const initialToken = (0, import_vue7.toValue)(options.token);
   const decimals = (0, import_connect_appkit_core5.createDecimalsCache)(initialToken, initialToken.decimals);
-  const isSending = (0, import_vue6.shallowRef)(false);
-  const error = (0, import_vue6.shallowRef)(null);
+  const isSending = (0, import_vue7.shallowRef)(false);
+  const error = (0, import_vue7.shallowRef)(null);
   let generation = 0;
   let disposed = false;
-  (0, import_vue6.watch)(
+  (0, import_vue7.watch)(
     [
-      () => (0, import_vue6.toValue)(options.token).address,
-      () => (0, import_vue6.toValue)(options.token).chainId,
-      () => (0, import_vue6.toValue)(options.token).decimals,
-      () => (0, import_vue6.toValue)(options.account),
-      () => (0, import_vue6.toValue)(options.chainId),
-      () => (0, import_vue6.toValue)(options.connected),
-      () => (0, import_vue6.toValue)(options.publicClient),
-      () => (0, import_vue6.unref)(options.sendTransaction)
+      () => (0, import_vue7.toValue)(options.token).address,
+      () => (0, import_vue7.toValue)(options.token).chainId,
+      () => (0, import_vue7.toValue)(options.token).decimals,
+      () => (0, import_vue7.toValue)(options.account),
+      () => (0, import_vue7.toValue)(options.chainId),
+      () => (0, import_vue7.toValue)(options.connected),
+      () => (0, import_vue7.toValue)(options.publicClient),
+      () => (0, import_vue7.unref)(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -616,20 +679,20 @@ function useERC20Transfer(options) {
   );
   const sendTransfer = async (to, amount) => {
     const own = ++generation;
-    const token = (0, import_vue6.toValue)(options.token);
-    const reader = (0, import_vue6.toValue)(options.publicClient);
+    const token = (0, import_vue7.toValue)(options.token);
+    const reader = (0, import_vue7.toValue)(options.publicClient);
     const stillCurrent = () => !disposed && own === generation;
     error.value = null;
     isSending.value = true;
     try {
       assertErc20Context(
         token,
-        (0, import_vue6.toValue)(options.chainId),
-        (0, import_vue6.toValue)(options.account),
-        (0, import_vue6.toValue)(options.connected)
+        (0, import_vue7.toValue)(options.chainId),
+        (0, import_vue7.toValue)(options.account),
+        (0, import_vue7.toValue)(options.connected)
       );
       if (!reader) {
-        throw new import_connect_core5.WalletError(
+        throw new import_connect_core6.WalletError(
           "wallet_unavailable",
           "No public client available"
         );
@@ -639,20 +702,20 @@ function useERC20Transfer(options) {
         precision = Number(
           await reader.readContract({
             address: token.address,
-            abi: import_connect_core5.ERC20_MIN_ABI,
+            abi: import_connect_core6.ERC20_MIN_ABI,
             functionName: "decimals"
           })
         );
         if (!stillCurrent()) {
-          throw new import_connect_core5.WalletError(
+          throw new import_connect_core6.WalletError(
             "session_inactive",
             "Wallet or token context changed. Retry the transfer."
           );
         }
         (0, import_connect_appkit_core5.writeDecimals)(decimals, token, precision);
       }
-      const data = (0, import_connect_appkit_core5.encodeErc20Transfer)(to, (0, import_connect_core5.parseUnits)(amount, precision));
-      return await (0, import_vue6.unref)(options.sendTransaction)({
+      const data = (0, import_connect_appkit_core5.encodeErc20Transfer)(to, (0, import_connect_core6.parseUnits)(amount, precision));
+      return await (0, import_vue7.unref)(options.sendTransaction)({
         to: token.address,
         data,
         value: "0"
@@ -665,7 +728,7 @@ function useERC20Transfer(options) {
       if (stillCurrent()) isSending.value = false;
     }
   };
-  (0, import_vue6.onScopeDispose)(() => {
+  (0, import_vue7.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -674,30 +737,30 @@ function useERC20Transfer(options) {
 
 // src/useERC20Approve.ts
 var import_connect_appkit_core6 = require("@naculus/connect-appkit-core");
-var import_connect_core6 = require("@naculus/connect-core");
-var import_vue7 = require("vue");
+var import_connect_core7 = require("@naculus/connect-core");
+var import_vue8 = require("vue");
 var MAX_UINT256 = (1n << 256n) - 1n;
 function useERC20Approve(options) {
-  const initialToken = (0, import_vue7.toValue)(options.token);
+  const initialToken = (0, import_vue8.toValue)(options.token);
   const decimals = (0, import_connect_appkit_core6.createDecimalsCache)(initialToken, initialToken.decimals);
-  const allowanceRaw = (0, import_vue7.shallowRef)(null);
-  const isApproving = (0, import_vue7.shallowRef)(false);
-  const isFetchingAllowance = (0, import_vue7.shallowRef)(false);
-  const error = (0, import_vue7.shallowRef)(null);
+  const allowanceRaw = (0, import_vue8.shallowRef)(null);
+  const isApproving = (0, import_vue8.shallowRef)(false);
+  const isFetchingAllowance = (0, import_vue8.shallowRef)(false);
+  const error = (0, import_vue8.shallowRef)(null);
   let generation = 0;
   let allowanceGeneration = 0;
   let disposed = false;
-  (0, import_vue7.watch)(
+  (0, import_vue8.watch)(
     [
-      () => (0, import_vue7.toValue)(options.token).address,
-      () => (0, import_vue7.toValue)(options.token).chainId,
-      () => (0, import_vue7.toValue)(options.token).decimals,
-      () => (0, import_vue7.toValue)(options.spender),
-      () => (0, import_vue7.toValue)(options.account),
-      () => (0, import_vue7.toValue)(options.chainId),
-      () => (0, import_vue7.toValue)(options.connected),
-      () => (0, import_vue7.toValue)(options.publicClient),
-      () => (0, import_vue7.unref)(options.sendTransaction)
+      () => (0, import_vue8.toValue)(options.token).address,
+      () => (0, import_vue8.toValue)(options.token).chainId,
+      () => (0, import_vue8.toValue)(options.token).decimals,
+      () => (0, import_vue8.toValue)(options.spender),
+      () => (0, import_vue8.toValue)(options.account),
+      () => (0, import_vue8.toValue)(options.chainId),
+      () => (0, import_vue8.toValue)(options.connected),
+      () => (0, import_vue8.toValue)(options.publicClient),
+      () => (0, import_vue8.unref)(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -710,17 +773,17 @@ function useERC20Approve(options) {
     { flush: "sync" }
   );
   const context = () => {
-    const token = (0, import_vue7.toValue)(options.token);
+    const token = (0, import_vue8.toValue)(options.token);
     const account = assertErc20Context(
       token,
-      (0, import_vue7.toValue)(options.chainId),
-      (0, import_vue7.toValue)(options.account),
-      (0, import_vue7.toValue)(options.connected)
+      (0, import_vue8.toValue)(options.chainId),
+      (0, import_vue8.toValue)(options.account),
+      (0, import_vue8.toValue)(options.connected)
     );
-    const reader = (0, import_vue7.toValue)(options.publicClient);
+    const reader = (0, import_vue8.toValue)(options.publicClient);
     if (!reader)
-      throw new import_connect_core6.WalletError("wallet_unavailable", "No public client");
-    return { token, account, reader, spender: (0, import_vue7.toValue)(options.spender) };
+      throw new import_connect_core7.WalletError("wallet_unavailable", "No public client");
+    return { token, account, reader, spender: (0, import_vue8.toValue)(options.spender) };
   };
   const readPrecision = async () => {
     const { token, reader } = context();
@@ -729,7 +792,7 @@ function useERC20Approve(options) {
       precision = Number(
         await reader.readContract({
           address: token.address,
-          abi: import_connect_core6.ERC20_MIN_ABI,
+          abi: import_connect_core7.ERC20_MIN_ABI,
           functionName: "decimals"
         })
       );
@@ -747,7 +810,7 @@ function useERC20Approve(options) {
       const raw = BigInt(
         await reader.readContract({
           address: token.address,
-          abi: import_connect_core6.ERC20_MIN_ABI,
+          abi: import_connect_core7.ERC20_MIN_ABI,
           functionName: "allowance",
           args: [account, spender]
         })
@@ -771,7 +834,7 @@ function useERC20Approve(options) {
     isApproving.value = true;
     try {
       const { token, spender } = context();
-      const hash = await (0, import_vue7.unref)(options.sendTransaction)({
+      const hash = await (0, import_vue8.unref)(options.sendTransaction)({
         to: token.address,
         data: (0, import_connect_appkit_core6.encodeErc20Approve)(spender, rawAmount),
         value: "0"
@@ -792,12 +855,12 @@ function useERC20Approve(options) {
     try {
       const precision = await readPrecision();
       if (contextGeneration !== generation || disposed) {
-        throw new import_connect_core6.WalletError(
+        throw new import_connect_core7.WalletError(
           "session_inactive",
           "Wallet or token context changed. Retry the approval."
         );
       }
-      rawAmount = (0, import_connect_core6.parseUnits)(amount, precision);
+      rawAmount = (0, import_connect_core7.parseUnits)(amount, precision);
     } catch (cause) {
       const normalized = cause instanceof Error ? cause : new Error("Approve failed");
       if (!disposed && contextGeneration === generation)
@@ -810,15 +873,15 @@ function useERC20Approve(options) {
   const hasAllowance = async (required) => {
     const raw = allowanceRaw.value ?? await refetchAllowance();
     if (raw === null) return false;
-    return raw >= (0, import_connect_core6.parseUnits)(required, await readPrecision());
+    return raw >= (0, import_connect_core7.parseUnits)(required, await readPrecision());
   };
-  const allowance = (0, import_vue7.computed)(() => {
+  const allowance = (0, import_vue8.computed)(() => {
     if (allowanceRaw.value === null) return null;
-    const token = (0, import_vue7.toValue)(options.token);
+    const token = (0, import_vue8.toValue)(options.token);
     const precision = (0, import_connect_appkit_core6.readDecimals)(decimals, token, token.decimals);
-    return precision === void 0 ? null : (0, import_connect_core6.formatUnits)(allowanceRaw.value, precision);
+    return precision === void 0 ? null : (0, import_connect_core7.formatUnits)(allowanceRaw.value, precision);
   });
-  (0, import_vue7.onScopeDispose)(() => {
+  (0, import_vue8.onScopeDispose)(() => {
     disposed = true;
     generation++;
     allowanceGeneration++;
@@ -838,20 +901,20 @@ function useERC20Approve(options) {
 
 // src/useERC20TransferSimulation.ts
 var import_connect_appkit_core7 = require("@naculus/connect-appkit-core");
-var import_connect_core7 = require("@naculus/connect-core");
-var import_vue8 = require("vue");
+var import_connect_core8 = require("@naculus/connect-core");
+var import_vue9 = require("vue");
 function useERC20TransferSimulation(options) {
-  const transaction = (0, import_vue8.computed)(() => {
-    const token = (0, import_vue8.toValue)(options.token);
-    if (!(0, import_vue8.toValue)(options.connected) || !(0, import_vue8.toValue)(options.evmAccount))
+  const transaction = (0, import_vue9.computed)(() => {
+    const token = (0, import_vue9.toValue)(options.token);
+    if (!(0, import_vue9.toValue)(options.connected) || !(0, import_vue9.toValue)(options.evmAccount))
       return void 0;
     try {
       if (token.decimals === void 0) return void 0;
       return {
         to: token.address,
         data: (0, import_connect_appkit_core7.encodeErc20Transfer)(
-          (0, import_vue8.toValue)(options.to),
-          (0, import_connect_core7.parseUnits)((0, import_vue8.toValue)(options.amount), token.decimals)
+          (0, import_vue9.toValue)(options.to),
+          (0, import_connect_core8.parseUnits)((0, import_vue9.toValue)(options.amount), token.decimals)
         ),
         value: "0"
       };
@@ -859,10 +922,10 @@ function useERC20TransferSimulation(options) {
       return void 0;
     }
   });
-  const chainId = (0, import_vue8.computed)(() => {
-    const token = (0, import_vue8.toValue)(options.token);
+  const chainId = (0, import_vue9.computed)(() => {
+    const token = (0, import_vue9.toValue)(options.token);
     if (token.chainId !== void 0) return token.chainId;
-    const currentChain = (0, import_vue8.toValue)(options.currentChain);
+    const currentChain = (0, import_vue9.toValue)(options.currentChain);
     return currentChain ? (0, import_connect_appkit_core7.chainNumber)(currentChain) ?? void 0 : void 0;
   });
   const simulation = useTransactionSimulation(transaction, {
@@ -872,39 +935,39 @@ function useERC20TransferSimulation(options) {
     evmAccount: options.evmAccount
   });
   return {
-    result: (0, import_vue8.computed)(
+    result: (0, import_vue9.computed)(
       () => transaction.value ? simulation.result.value : void 0
     ),
-    isSimulating: (0, import_vue8.computed)(
+    isSimulating: (0, import_vue9.computed)(
       () => !!transaction.value && simulation.isSimulating.value
     ),
-    error: (0, import_vue8.computed)(() => transaction.value ? simulation.error.value : null),
+    error: (0, import_vue9.computed)(() => transaction.value ? simulation.error.value : null),
     reSimulate: simulation.simulate,
     reset: simulation.reset
   };
 }
 
 // src/useAccount.ts
-var import_vue9 = require("vue");
+var import_vue10 = require("vue");
 function useAccount(accounts, connected) {
   const parsed = useAccounts(accounts);
-  const isConnected = (0, import_vue9.computed)(() => (0, import_vue9.toValue)(connected));
-  const accountList = (0, import_vue9.computed)(() => (0, import_vue9.toValue)(accounts) ?? []);
+  const isConnected = (0, import_vue10.computed)(() => (0, import_vue10.toValue)(connected));
+  const accountList = (0, import_vue10.computed)(() => (0, import_vue10.toValue)(accounts) ?? []);
   return {
-    accounts: (0, import_vue9.computed)(
+    accounts: (0, import_vue10.computed)(
       () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
     ),
-    evmAccount: (0, import_vue9.computed)(
+    evmAccount: (0, import_vue10.computed)(
       () => isConnected.value ? parsed.evmAccount.value : null
     ),
-    primaryAccount: (0, import_vue9.computed)(() => accountList.value[0] ?? null),
+    primaryAccount: (0, import_vue10.computed)(() => accountList.value[0] ?? null),
     isConnected,
-    count: (0, import_vue9.computed)(() => accountList.value.length)
+    count: (0, import_vue10.computed)(() => accountList.value.length)
   };
 }
 
 // src/useSession.ts
-var import_vue10 = require("vue");
+var import_vue11 = require("vue");
 function readSession(manager) {
   const bundle = manager?.getActiveBundle();
   if (!bundle) {
@@ -923,9 +986,9 @@ function readSession(manager) {
   };
 }
 function useSession(manager) {
-  const snapshot = (0, import_vue10.shallowRef)(readSession((0, import_vue10.toValue)(manager)));
-  (0, import_vue10.watch)(
-    () => (0, import_vue10.toValue)(manager),
+  const snapshot = (0, import_vue11.shallowRef)(readSession((0, import_vue11.toValue)(manager)));
+  (0, import_vue11.watch)(
+    () => (0, import_vue11.toValue)(manager),
     (current, _previous, onCleanup) => {
       const update = () => {
         snapshot.value = readSession(current);
@@ -948,29 +1011,29 @@ function useSession(manager) {
     { immediate: true }
   );
   return {
-    session: (0, import_vue10.computed)(() => snapshot.value.session),
-    chainSessions: (0, import_vue10.computed)(() => snapshot.value.chainSessions),
-    activeChainId: (0, import_vue10.computed)(() => snapshot.value.activeChainId),
-    isConnected: (0, import_vue10.computed)(() => snapshot.value.session !== null),
-    connectorId: (0, import_vue10.computed)(() => snapshot.value.connectorId)
+    session: (0, import_vue11.computed)(() => snapshot.value.session),
+    chainSessions: (0, import_vue11.computed)(() => snapshot.value.chainSessions),
+    activeChainId: (0, import_vue11.computed)(() => snapshot.value.activeChainId),
+    isConnected: (0, import_vue11.computed)(() => snapshot.value.session !== null),
+    connectorId: (0, import_vue11.computed)(() => snapshot.value.connectorId)
   };
 }
 
 // src/useConnect.ts
-var import_connect_core8 = require("@naculus/connect-core");
-var import_vue11 = require("vue");
+var import_connect_core9 = require("@naculus/connect-core");
+var import_vue12 = require("vue");
 function useConnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
   const connect = () => {
     if (inFlight) return inFlight;
-    const invoke = (0, import_vue11.unref)(action);
+    const invoke = (0, import_vue12.unref)(action);
     const pending = guard.run(
       () => Promise.resolve().then(() => invoke()),
       "Connection failed",
       (cause) => {
         const message = cause instanceof Error ? cause.message : "Connection failed";
-        return cause instanceof import_connect_core8.WalletError ? cause : new Error(message);
+        return cause instanceof import_connect_core9.WalletError ? cause : new Error(message);
       }
     ).catch(() => {
     }).finally(() => {
@@ -981,22 +1044,22 @@ function useConnect(action, status) {
   };
   return {
     connect,
-    isConnecting: (0, import_vue11.computed)(
-      () => guard.busy.value || (0, import_vue11.toValue)(status) === "connecting"
+    isConnecting: (0, import_vue12.computed)(
+      () => guard.busy.value || (0, import_vue12.toValue)(status) === "connecting"
     ),
     error: guard.error
   };
 }
 
 // src/useDisconnect.ts
-var import_vue12 = require("vue");
+var import_vue13 = require("vue");
 function useDisconnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
   const disconnect = () => {
     if (inFlight) return inFlight;
-    if ((0, import_vue12.toValue)(status) === "disconnected") return Promise.resolve();
-    const invoke = (0, import_vue12.unref)(action);
+    if ((0, import_vue13.toValue)(status) === "disconnected") return Promise.resolve();
+    const invoke = (0, import_vue13.unref)(action);
     const pending = guard.run(() => Promise.resolve().then(() => invoke()), "Disconnect failed").catch(() => {
     }).finally(() => {
       if (inFlight === pending) inFlight = null;
@@ -1017,11 +1080,11 @@ function useDisconnect(action, status) {
 
 // src/useSwitchChain.ts
 var import_connect_appkit_core8 = require("@naculus/connect-appkit-core");
-var import_vue13 = require("vue");
+var import_vue14 = require("vue");
 function useSwitchChain(action, chainId) {
   const guard = useActionGuard();
   const switchChain = (targetChainId) => {
-    const invoke = (0, import_vue13.unref)(action);
+    const invoke = (0, import_vue14.unref)(action);
     return guard.run(async () => {
       try {
         await invoke(targetChainId);
@@ -1033,18 +1096,18 @@ function useSwitchChain(action, chainId) {
   return {
     switchChain,
     isSwitching: guard.busy,
-    currentChainId: (0, import_vue13.computed)(() => (0, import_vue13.toValue)(chainId) ?? null),
+    currentChainId: (0, import_vue14.computed)(() => (0, import_vue14.toValue)(chainId) ?? null),
     error: guard.error,
     clearError: guard.clearError
   };
 }
 
 // src/useSignMessage.ts
-var import_vue14 = require("vue");
+var import_vue15 = require("vue");
 function useSignMessage(action) {
   const guard = useActionGuard();
   const signMessage = (message) => {
-    const invoke = (0, import_vue14.unref)(action);
+    const invoke = (0, import_vue15.unref)(action);
     return guard.run(() => invoke(message), "Signing failed");
   };
   return {
@@ -1056,12 +1119,12 @@ function useSignMessage(action) {
 }
 
 // src/useSendTransaction.ts
-var import_vue15 = require("vue");
+var import_vue16 = require("vue");
 function useSendTransaction(action) {
   const guard = useActionGuard();
-  const status = (0, import_vue15.shallowRef)("idle");
+  const status = (0, import_vue16.shallowRef)("idle");
   const sendTransaction = (transaction) => {
-    const invoke = (0, import_vue15.unref)(action);
+    const invoke = (0, import_vue16.unref)(action);
     status.value = "awaiting_approval";
     return guard.run(async (commit) => {
       const hash = await invoke(transaction);
@@ -1083,20 +1146,20 @@ function useSendTransaction(action) {
     status,
     error: guard.error,
     reset,
-    isSending: (0, import_vue15.computed)(() => status.value === "awaiting_approval")
+    isSending: (0, import_vue16.computed)(() => status.value === "awaiting_approval")
   };
 }
 
 // src/useSolanaTransaction.ts
-var import_vue16 = require("vue");
+var import_vue17 = require("vue");
 function useSolanaTransaction(options) {
   const guard = useActionGuard();
-  const isSigning = (0, import_vue16.shallowRef)(false);
-  const isSending = (0, import_vue16.shallowRef)(false);
+  const isSigning = (0, import_vue17.shallowRef)(false);
+  const isSending = (0, import_vue17.shallowRef)(false);
   let signing = 0;
   let sending = 0;
   const signTransaction = (transaction) => {
-    const invoke = (0, import_vue16.unref)(options.signTransaction);
+    const invoke = (0, import_vue17.unref)(options.signTransaction);
     signing++;
     isSigning.value = true;
     return guard.run(() => invoke(transaction), "Signing failed").finally(() => {
@@ -1105,7 +1168,7 @@ function useSolanaTransaction(options) {
     });
   };
   const sendTransaction = (transaction) => {
-    const invoke = (0, import_vue16.unref)(options.sendTransaction);
+    const invoke = (0, import_vue17.unref)(options.sendTransaction);
     sending++;
     isSending.value = true;
     return guard.run(() => invoke(transaction), "Send failed").finally(() => {
@@ -1113,7 +1176,7 @@ function useSolanaTransaction(options) {
       isSending.value = sending > 0;
     });
   };
-  const getStatus = (signature) => (0, import_vue16.unref)(options.getStatus)(signature);
+  const getStatus = (signature) => (0, import_vue17.unref)(options.getStatus)(signature);
   return {
     signTransaction,
     sendTransaction,
@@ -1126,12 +1189,12 @@ function useSolanaTransaction(options) {
 }
 
 // src/useSignInWithX.ts
-var import_vue17 = require("vue");
+var import_vue18 = require("vue");
 function useSignInWithX(action) {
   const guard = useActionGuard();
-  const result = (0, import_vue17.shallowRef)(null);
+  const result = (0, import_vue18.shallowRef)(null);
   const signIn = (options) => {
-    const invoke = (0, import_vue17.unref)(action);
+    const invoke = (0, import_vue18.unref)(action);
     return guard.run(async (commit) => {
       const next = await invoke(options);
       commit(() => {
@@ -1160,48 +1223,48 @@ function useSignInWithEthereum(action) {
 }
 
 // src/useExecuteCalls.ts
-var import_vue18 = require("vue");
+var import_vue19 = require("vue");
 function useExecuteCalls(options) {
   const guard = useActionGuard();
-  const preview = (callCount, atomicity) => (0, import_vue18.unref)(options.preview)(callCount, atomicity);
+  const preview = (callCount, atomicity) => (0, import_vue19.unref)(options.preview)(callCount, atomicity);
   const execute = (calls, atomicity) => {
-    const invoke = (0, import_vue18.unref)(options.execute);
+    const invoke = (0, import_vue19.unref)(options.execute);
     return guard.run(() => invoke(calls, atomicity), "Execution failed");
   };
   const reset = () => {
     guard.reset();
-    (0, import_vue18.unref)(options.reset)();
+    (0, import_vue19.unref)(options.reset)();
   };
   return {
     preview,
     execute,
     isExecuting: guard.busy,
     error: guard.error,
-    lastRoute: (0, import_vue18.computed)(() => (0, import_vue18.toValue)(options.lastRoute)),
+    lastRoute: (0, import_vue19.computed)(() => (0, import_vue19.toValue)(options.lastRoute)),
     reset
   };
 }
 
 // src/useDelegationPolicy.ts
 var import_connect_appkit_core10 = require("@naculus/connect-appkit-core");
-var import_vue20 = require("vue");
+var import_vue21 = require("vue");
 
 // src/useSessionKeys.ts
 var import_connect_appkit_core9 = require("@naculus/connect-appkit-core");
-var import_vue19 = require("vue");
+var import_vue20 = require("vue");
 function resolveManager(config, options) {
   return options.manager ?? (0, import_connect_appkit_core9.getSharedSessionKeyManager)(config);
 }
 function useSessionKeys(connected, config, options = {}) {
   const manager = resolveManager(config, options);
-  const sessions = (0, import_vue19.shallowRef)([]);
-  const loading = (0, import_vue19.shallowRef)(false);
-  const error = (0, import_vue19.shallowRef)(null);
+  const sessions = (0, import_vue20.shallowRef)([]);
+  const loading = (0, import_vue20.shallowRef)(false);
+  const error = (0, import_vue20.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const refresh = async () => {
     const own = ++generation;
-    if (!(0, import_vue19.toValue)(connected)) {
+    if (!(0, import_vue20.toValue)(connected)) {
       sessions.value = [];
       return;
     }
@@ -1218,20 +1281,20 @@ function useSessionKeys(connected, config, options = {}) {
       if (!disposed && own === generation) loading.value = false;
     }
   };
-  (0, import_vue19.watch)(
-    () => (0, import_vue19.toValue)(connected),
+  (0, import_vue20.watch)(
+    () => (0, import_vue20.toValue)(connected),
     () => {
       void refresh();
     },
     { immediate: true }
   );
-  (0, import_vue19.onScopeDispose)(() => {
+  (0, import_vue20.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
   return {
     sessions,
-    activeSessions: (0, import_vue19.computed)(
+    activeSessions: (0, import_vue20.computed)(
       () => sessions.value.filter((s) => s.status === "active")
     ),
     loading,
@@ -1246,7 +1309,7 @@ function useSessionKeys(connected, config, options = {}) {
 function useCreateSessionKey(config, options = {}) {
   const manager = resolveManager(config, options);
   const guard = useActionGuard();
-  const lastCreated = (0, import_vue19.shallowRef)(null);
+  const lastCreated = (0, import_vue20.shallowRef)(null);
   return {
     createSessionKey: (scope, signerAddress) => guard.run(async () => {
       const info = await manager.createSessionKey(scope, signerAddress);
@@ -1297,31 +1360,31 @@ function useDelegationPolicy(options) {
     manager
   });
   const guard = useActionGuard();
-  const verifiedIds = (0, import_vue20.shallowRef)(/* @__PURE__ */ new Set());
-  const isVerifying = (0, import_vue20.shallowRef)(false);
-  const verifyError = (0, import_vue20.shallowRef)(null);
+  const verifiedIds = (0, import_vue21.shallowRef)(/* @__PURE__ */ new Set());
+  const isVerifying = (0, import_vue21.shallowRef)(false);
+  const verifyError = (0, import_vue21.shallowRef)(null);
   let verifyGeneration = 0;
   let disposed = false;
   const origin = options.origin ?? (typeof window !== "undefined" ? window.location.origin : "unknown");
   const flow = (0, import_connect_appkit_core10.createDelegationPolicyFlow)({
     manager,
     origin,
-    signer: () => (0, import_connect_appkit_core10.bareEvmAddress)((0, import_vue20.toValue)(options.account)),
-    signMessage: (message) => (0, import_vue20.unref)(options.signMessage)(message),
-    verifySignature: (input) => (0, import_vue20.unref)(options.verifySignature)(input),
-    previewExecution: (callCount, atomicity) => (0, import_vue20.unref)(options.previewExecution)(callCount, atomicity),
+    signer: () => (0, import_connect_appkit_core10.bareEvmAddress)((0, import_vue21.toValue)(options.account)),
+    signMessage: (message) => (0, import_vue21.unref)(options.signMessage)(message),
+    verifySignature: (input) => (0, import_vue21.unref)(options.verifySignature)(input),
+    previewExecution: (callCount, atomicity) => (0, import_vue21.unref)(options.previewExecution)(callCount, atomicity),
     sponsorship: options.sponsorship,
     adapter: options.adapter,
-    signTypedData: options.signTypedData ? (typedData) => (0, import_vue20.unref)(
+    signTypedData: options.signTypedData ? (typedData) => (0, import_vue21.unref)(
       options.signTypedData
     )(typedData) : void 0,
-    chainId: () => (0, import_vue20.toValue)(options.chainId) ?? null,
-    delegation: () => (0, import_vue20.toValue)(options.delegation),
+    chainId: () => (0, import_vue21.toValue)(options.chainId) ?? null,
+    delegation: () => (0, import_vue21.toValue)(options.delegation),
     encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
     storageAvailable: () => sessionKeys.storageAvailable,
     refresh: sessionKeys.refresh
   });
-  (0, import_vue20.watch)(
+  (0, import_vue21.watch)(
     () => sessionKeys.sessions.value,
     (sessions) => {
       const own = ++verifyGeneration;
@@ -1351,21 +1414,21 @@ function useDelegationPolicy(options) {
     },
     { immediate: true }
   );
-  (0, import_vue20.onScopeDispose)(() => {
+  (0, import_vue21.onScopeDispose)(() => {
     disposed = true;
     verifyGeneration++;
   });
   return {
     policies: sessionKeys.sessions,
-    activePolicies: (0, import_vue20.computed)(
+    activePolicies: (0, import_vue21.computed)(
       () => sessionKeys.activeSessions.value.filter(
         (p) => verifiedIds.value.has(p.id)
       )
     ),
     storageAvailable: sessionKeys.storageAvailable,
-    loading: (0, import_vue20.computed)(() => sessionKeys.loading.value || isVerifying.value),
+    loading: (0, import_vue21.computed)(() => sessionKeys.loading.value || isVerifying.value),
     isBusy: guard.busy,
-    error: (0, import_vue20.computed)(
+    error: (0, import_vue21.computed)(
       () => guard.error.value ?? verifyError.value ?? sessionKeys.error.value
     ),
     createPolicy: (scope) => guard.run(() => flow.createPolicy(scope), "Policy creation failed"),
@@ -1387,28 +1450,28 @@ function useDelegationPolicy(options) {
 
 // src/useSmartAccount.ts
 var import_connect_appkit_core11 = require("@naculus/connect-appkit-core");
-var import_connect_core9 = require("@naculus/connect-core");
-var import_vue21 = require("vue");
+var import_connect_core10 = require("@naculus/connect-core");
+var import_vue22 = require("vue");
 function useSmartAccount(options) {
-  const address = (0, import_vue21.shallowRef)(null);
-  const isDeployed = (0, import_vue21.shallowRef)(false);
-  const accountInfo = (0, import_vue21.shallowRef)(null);
+  const address = (0, import_vue22.shallowRef)(null);
+  const isDeployed = (0, import_vue22.shallowRef)(false);
+  const accountInfo = (0, import_vue22.shallowRef)(null);
   const guard = useActionGuard();
-  const managerRef = (0, import_vue21.shallowRef)(null);
+  const managerRef = (0, import_vue22.shallowRef)(null);
   let generation = 0;
   let inFlight = false;
   let disposed = false;
-  const chainId = (0, import_vue21.computed)(
+  const chainId = (0, import_vue22.computed)(
     () => (0, import_connect_appkit_core11.resolveEvmChainId)(
-      (0, import_vue21.toValue)(options.chainId),
-      (0, import_vue21.toValue)(options.connectedChainId)
+      (0, import_vue22.toValue)(options.chainId),
+      (0, import_vue22.toValue)(options.connectedChainId)
     )
   );
-  (0, import_vue21.watch)(
+  (0, import_vue22.watch)(
     [
-      () => (0, import_vue21.toValue)(options.manager),
-      () => (0, import_vue21.toValue)(options.rpcUrl),
-      () => (0, import_vue21.toValue)(options.bundlerUrl),
+      () => (0, import_vue22.toValue)(options.manager),
+      () => (0, import_vue22.toValue)(options.rpcUrl),
+      () => (0, import_vue22.toValue)(options.bundlerUrl),
       () => chainId.value
     ],
     ([supplied, rpcUrl, bundlerUrl, chain]) => {
@@ -1433,8 +1496,8 @@ function useSmartAccount(options) {
     },
     { immediate: true }
   );
-  const config = (0, import_vue21.computed)(() => {
-    const owner = (0, import_connect_appkit_core11.bareEvmAddress)((0, import_vue21.toValue)(options.account));
+  const config = (0, import_vue22.computed)(() => {
+    const owner = (0, import_connect_appkit_core11.bareEvmAddress)((0, import_vue22.toValue)(options.account));
     const chain = chainId.value;
     if (!owner || !chain || !managerRef.value) return null;
     return (0, import_connect_appkit_core11.buildSmartAccountConfig)(owner, chain, {
@@ -1484,9 +1547,9 @@ function useSmartAccount(options) {
     return info;
   }, "Failed to create smart account");
   const deployWallet = () => operate(async (manager, cfg, commit) => {
-    const send = (0, import_vue21.unref)(options.sendTransaction);
+    const send = (0, import_vue22.unref)(options.sendTransaction);
     if (!send) {
-      throw new import_connect_core9.WalletError(
+      throw new import_connect_core10.WalletError(
         "wallet_unavailable",
         "deployWallet needs the connected wallet's sendTransaction"
       );
@@ -1514,7 +1577,7 @@ function useSmartAccount(options) {
     });
     return addr;
   }, "Failed to get smart account address");
-  (0, import_vue21.onScopeDispose)(() => {
+  (0, import_vue22.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -1533,14 +1596,14 @@ function useSmartAccount(options) {
 
 // src/useSendUserOperation.ts
 var import_connect_appkit_core12 = require("@naculus/connect-appkit-core");
-var import_connect_core10 = require("@naculus/connect-core");
-var import_vue22 = require("vue");
+var import_connect_core11 = require("@naculus/connect-core");
+var import_vue23 = require("vue");
 function useSendUserOperation(options) {
-  const userOpHash = (0, import_vue22.shallowRef)(null);
-  const receipt = (0, import_vue22.shallowRef)(null);
-  const isPending = (0, import_vue22.shallowRef)(false);
-  const isEstimating = (0, import_vue22.shallowRef)(false);
-  const error = (0, import_vue22.shallowRef)(null);
+  const userOpHash = (0, import_vue23.shallowRef)(null);
+  const receipt = (0, import_vue23.shallowRef)(null);
+  const isPending = (0, import_vue23.shallowRef)(false);
+  const isEstimating = (0, import_vue23.shallowRef)(false);
+  const error = (0, import_vue23.shallowRef)(null);
   let requestId = 0;
   let inFlight = false;
   let disposed = false;
@@ -1549,8 +1612,8 @@ function useSendUserOperation(options) {
     return null;
   };
   const sendUserOp = async (calls, opts) => {
-    const rpcUrl = (0, import_vue22.toValue)(options.rpcUrl);
-    const bundlerUrl = (0, import_vue22.toValue)(options.bundlerUrl);
+    const rpcUrl = (0, import_vue23.toValue)(options.rpcUrl);
+    const bundlerUrl = (0, import_vue23.toValue)(options.bundlerUrl);
     if (!rpcUrl) return fail(new Error("RPC URL not configured"));
     if (!bundlerUrl) return fail(new Error("Bundler URL not configured"));
     if (!calls.length) return fail(new Error("At least one call is required"));
@@ -1558,23 +1621,23 @@ function useSendUserOperation(options) {
       return fail(new Error("A UserOperation is already in progress"));
     }
     const owner = (0, import_connect_appkit_core12.bareEvmAddress)(
-      (0, import_vue22.toValue)(options.owner) ?? (0, import_vue22.toValue)(options.account)
+      (0, import_vue23.toValue)(options.owner) ?? (0, import_vue23.toValue)(options.account)
     );
     if (!owner) {
       return fail(
-        new import_connect_core10.WalletError("wallet_unavailable", "No EVM account found")
+        new import_connect_core11.WalletError("wallet_unavailable", "No EVM account found")
       );
     }
     let targetChainId;
     try {
       targetChainId = (0, import_connect_appkit_core12.resolveUserOpChain)(
-        (0, import_vue22.toValue)(options.chainId),
-        (0, import_vue22.toValue)(options.connectedChainId)
+        (0, import_vue23.toValue)(options.chainId),
+        (0, import_vue23.toValue)(options.connectedChainId)
       );
     } catch (chainError) {
       return fail(chainError);
     }
-    const signer = (0, import_vue22.unref)(options.signer);
+    const signer = (0, import_vue23.unref)(options.signer);
     const own = ++requestId;
     inFlight = true;
     isPending.value = true;
@@ -1625,7 +1688,7 @@ function useSendUserOperation(options) {
     isEstimating.value = false;
     error.value = null;
   };
-  (0, import_vue22.onScopeDispose)(() => {
+  (0, import_vue23.onScopeDispose)(() => {
     disposed = true;
     requestId++;
   });
@@ -1642,15 +1705,15 @@ function useSendUserOperation(options) {
 
 // src/useUserOpStatus.ts
 var import_connect_appkit_core13 = require("@naculus/connect-appkit-core");
-var import_vue23 = require("vue");
+var import_vue24 = require("vue");
 function useUserOpStatus(options) {
-  const status = (0, import_vue23.shallowRef)("idle");
-  const receipt = (0, import_vue23.shallowRef)(null);
-  const userOpHash = (0, import_vue23.shallowRef)(null);
-  const error = (0, import_vue23.shallowRef)(null);
-  const isPolling = (0, import_vue23.shallowRef)(false);
-  const elapsedMs = (0, import_vue23.shallowRef)(0);
-  const attempts = (0, import_vue23.shallowRef)(0);
+  const status = (0, import_vue24.shallowRef)("idle");
+  const receipt = (0, import_vue24.shallowRef)(null);
+  const userOpHash = (0, import_vue24.shallowRef)(null);
+  const error = (0, import_vue24.shallowRef)(null);
+  const isPolling = (0, import_vue24.shallowRef)(false);
+  const elapsedMs = (0, import_vue24.shallowRef)(0);
+  const attempts = (0, import_vue24.shallowRef)(0);
   const pollInterval = options.pollInterval ?? 2e3;
   const maxRetries = options.maxRetries ?? 30;
   let generation = 0;
@@ -1671,7 +1734,7 @@ function useUserOpStatus(options) {
     clearTimers();
   };
   const poll = async (hash, own) => {
-    const bundlerUrl = (0, import_vue23.toValue)(options.bundlerUrl);
+    const bundlerUrl = (0, import_vue24.toValue)(options.bundlerUrl);
     if (!bundlerUrl || own !== generation) return;
     const attempt = ++attempts.value;
     const abort = new AbortController();
@@ -1728,7 +1791,7 @@ function useUserOpStatus(options) {
     error.value = null;
     attempts.value = 0;
     elapsedMs.value = 0;
-    if (!(0, import_vue23.toValue)(options.bundlerUrl)) {
+    if (!(0, import_vue24.toValue)(options.bundlerUrl)) {
       finish("not_found", new Error("Bundler URL not configured"));
       return;
     }
@@ -1756,7 +1819,7 @@ function useUserOpStatus(options) {
     attempts.value = 0;
     elapsedMs.value = 0;
   };
-  (0, import_vue23.onScopeDispose)(stop);
+  (0, import_vue24.onScopeDispose)(stop);
   return {
     status,
     receipt,
@@ -1772,17 +1835,17 @@ function useUserOpStatus(options) {
 }
 
 // src/useSendCalls.ts
-var import_vue24 = require("vue");
+var import_vue25 = require("vue");
 function useSendCalls(options) {
-  const status = (0, import_vue24.shallowRef)("idle");
-  const error = (0, import_vue24.shallowRef)(null);
-  const batchHash = (0, import_vue24.shallowRef)(null);
-  const callsStatus = (0, import_vue24.shallowRef)(null);
+  const status = (0, import_vue25.shallowRef)("idle");
+  const error = (0, import_vue25.shallowRef)(null);
+  const batchHash = (0, import_vue25.shallowRef)(null);
+  const callsStatus = (0, import_vue25.shallowRef)(null);
   let sendGeneration = 0;
   let statusGeneration = 0;
   let disposed = false;
   const sendCalls = async (calls, input) => {
-    const invoke = (0, import_vue24.unref)(options.sendCalls);
+    const invoke = (0, import_vue25.unref)(options.sendCalls);
     const own = ++sendGeneration;
     status.value = "awaiting_approval";
     error.value = null;
@@ -1804,13 +1867,13 @@ function useSendCalls(options) {
     }
   };
   const getCallsStatus = async (hash) => {
-    const invoke = (0, import_vue24.unref)(options.getCallsStatus);
+    const invoke = (0, import_vue25.unref)(options.getCallsStatus);
     const own = ++statusGeneration;
     const result = await invoke(hash);
     if (!disposed && own === statusGeneration) callsStatus.value = result;
     return result;
   };
-  const showCallsStatus = (hash) => (0, import_vue24.unref)(options.showCallsStatus)(hash);
+  const showCallsStatus = (hash) => (0, import_vue25.unref)(options.showCallsStatus)(hash);
   const reset = () => {
     sendGeneration++;
     statusGeneration++;
@@ -1819,7 +1882,7 @@ function useSendCalls(options) {
     batchHash.value = null;
     callsStatus.value = null;
   };
-  (0, import_vue24.onScopeDispose)(() => {
+  (0, import_vue25.onScopeDispose)(() => {
     disposed = true;
     sendGeneration++;
     statusGeneration++;
@@ -1832,38 +1895,38 @@ function useSendCalls(options) {
     error,
     batchHash,
     callsStatus,
-    execution: (0, import_vue24.computed)(() => (0, import_vue24.toValue)(options.execution) ?? null),
-    isSending: (0, import_vue24.computed)(() => status.value === "awaiting_approval"),
+    execution: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.execution) ?? null),
+    isSending: (0, import_vue25.computed)(() => status.value === "awaiting_approval"),
     reset
   };
 }
 
 // src/useEmbeddedWallet.ts
-var import_vue25 = require("vue");
+var import_vue26 = require("vue");
 function useEmbeddedWallet(options) {
   const guard = useActionGuard();
   const run = (action) => guard.run(action, "Embedded wallet action failed");
-  const wallet = (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.wallet));
+  const wallet = (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.wallet));
   return {
     wallet,
-    hasWallet: (0, import_vue25.computed)(() => wallet.value !== null),
-    address: (0, import_vue25.computed)(() => wallet.value?.address ?? null),
-    accounts: (0, import_vue25.computed)(() => wallet.value?.accounts ?? []),
-    activeNamespace: (0, import_vue25.computed)(() => wallet.value?.activeNamespace ?? null),
-    backupPending: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.backupPending)),
-    storageSecurityLevel: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.storageSecurityLevel)),
-    securityReport: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.securityReport)),
-    connectEmbedded: () => run(() => (0, import_vue25.unref)(options.connectEmbedded)()),
-    restoreWallet: () => run(() => (0, import_vue25.unref)(options.restoreWallet)()),
-    generateWallet: () => run(() => (0, import_vue25.unref)(options.generateWallet)()),
-    importFromMnemonic: (value) => run(() => (0, import_vue25.unref)(options.importFromMnemonic)(value)),
-    importFromPrivateKey: (value) => run(() => (0, import_vue25.unref)(options.importFromPrivateKey)(value)),
-    wipe: () => run(() => (0, import_vue25.unref)(options.wipe)()),
-    setActiveNamespace: (value) => (0, import_vue25.unref)(options.setActiveNamespace)(value),
-    backfillAccounts: () => run(() => (0, import_vue25.unref)(options.backfillAccounts)()),
-    getSeedPhrase: () => (0, import_vue25.unref)(options.getSeedPhrase)(),
-    getPrivateKey: () => (0, import_vue25.unref)(options.getPrivateKey)(),
-    confirmBackup: () => (0, import_vue25.unref)(options.confirmBackup)(),
+    hasWallet: (0, import_vue26.computed)(() => wallet.value !== null),
+    address: (0, import_vue26.computed)(() => wallet.value?.address ?? null),
+    accounts: (0, import_vue26.computed)(() => wallet.value?.accounts ?? []),
+    activeNamespace: (0, import_vue26.computed)(() => wallet.value?.activeNamespace ?? null),
+    backupPending: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.backupPending)),
+    storageSecurityLevel: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.storageSecurityLevel)),
+    securityReport: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.securityReport)),
+    connectEmbedded: () => run(() => (0, import_vue26.unref)(options.connectEmbedded)()),
+    restoreWallet: () => run(() => (0, import_vue26.unref)(options.restoreWallet)()),
+    generateWallet: () => run(() => (0, import_vue26.unref)(options.generateWallet)()),
+    importFromMnemonic: (value) => run(() => (0, import_vue26.unref)(options.importFromMnemonic)(value)),
+    importFromPrivateKey: (value) => run(() => (0, import_vue26.unref)(options.importFromPrivateKey)(value)),
+    wipe: () => run(() => (0, import_vue26.unref)(options.wipe)()),
+    setActiveNamespace: (value) => (0, import_vue26.unref)(options.setActiveNamespace)(value),
+    backfillAccounts: () => run(() => (0, import_vue26.unref)(options.backfillAccounts)()),
+    getSeedPhrase: () => (0, import_vue26.unref)(options.getSeedPhrase)(),
+    getPrivateKey: () => (0, import_vue26.unref)(options.getPrivateKey)(),
+    confirmBackup: () => (0, import_vue26.unref)(options.confirmBackup)(),
     isBusy: guard.busy,
     error: guard.error,
     clearError: guard.clearError
@@ -1882,43 +1945,43 @@ function useSIWxLogin(action) {
 }
 
 // src/useSIWxSession.ts
-var import_vue26 = require("vue");
+var import_vue27 = require("vue");
 function useSIWxSession(options) {
   const guard = useActionGuard();
   return {
-    session: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.session)),
-    isAuthenticated: (0, import_vue26.computed)(
-      () => (0, import_vue26.toValue)(options.session) !== null && !(0, import_vue26.toValue)(options.isExpired)
+    session: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.session)),
+    isAuthenticated: (0, import_vue27.computed)(
+      () => (0, import_vue27.toValue)(options.session) !== null && !(0, import_vue27.toValue)(options.isExpired)
     ),
-    isRestoring: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.isRestoring)),
+    isRestoring: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.isRestoring)),
     isSigningIn: guard.busy,
-    isExpired: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.isExpired)),
-    timeUntilExpiry: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.timeUntilExpiry)),
-    signIn: (input) => guard.run(() => (0, import_vue26.unref)(options.signIn)(input), "SIWX sign-in failed"),
+    isExpired: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.isExpired)),
+    timeUntilExpiry: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.timeUntilExpiry)),
+    signIn: (input) => guard.run(() => (0, import_vue27.unref)(options.signIn)(input), "SIWX sign-in failed"),
     signOut: async () => {
-      await (0, import_vue26.unref)(options.signOut)();
+      await (0, import_vue27.unref)(options.signOut)();
       guard.clearError();
     },
-    refresh: () => guard.run(() => (0, import_vue26.unref)(options.refresh)(), "Session refresh failed"),
+    refresh: () => guard.run(() => (0, import_vue27.unref)(options.refresh)(), "Session refresh failed"),
     error: guard.error,
     clearError: guard.clearError
   };
 }
 
 // src/useSiwxAuthSession.ts
-var import_vue27 = require("vue");
+var import_vue28 = require("vue");
 function useSiwxAuthSession(options) {
   const guard = useActionGuard();
-  const signIn = (input) => guard.run(() => (0, import_vue27.unref)(options.signIn)(input), "SIWX sign-in failed");
+  const signIn = (input) => guard.run(() => (0, import_vue28.unref)(options.signIn)(input), "SIWX sign-in failed");
   const signOut = async () => {
     guard.reset();
-    await (0, import_vue27.unref)(options.signOut)();
+    await (0, import_vue28.unref)(options.signOut)();
     guard.clearError();
   };
-  const siwxResult = (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.result));
+  const siwxResult = (0, import_vue28.computed)(() => (0, import_vue28.toValue)(options.result));
   return {
-    isSignedIn: (0, import_vue27.computed)(() => siwxResult.value !== null),
-    isRestoring: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.isRestoring)),
+    isSignedIn: (0, import_vue28.computed)(() => siwxResult.value !== null),
+    isRestoring: (0, import_vue28.computed)(() => (0, import_vue28.toValue)(options.isRestoring)),
     siwxResult,
     isSigningIn: guard.busy,
     error: guard.error,
@@ -1930,16 +1993,16 @@ function useSiwxAuthSession(options) {
 
 // src/useBalance.ts
 var import_connect_appkit_core14 = require("@naculus/connect-appkit-core");
-var import_connect_core11 = require("@naculus/connect-core");
-var import_vue28 = require("vue");
+var import_connect_core12 = require("@naculus/connect-core");
+var import_vue29 = require("vue");
 function useBalance(account, client, options = {}) {
   const guard = useActionGuard();
-  const balance = (0, import_vue28.shallowRef)(null);
-  const isFetching = (0, import_vue28.shallowRef)(false);
+  const balance = (0, import_vue29.shallowRef)(null);
+  const isFetching = (0, import_vue29.shallowRef)(false);
   let timer = null;
   const refetch = async () => {
-    const reader = (0, import_vue28.toValue)(client);
-    const address = (0, import_connect_appkit_core14.bareEvmAddress)((0, import_vue28.toValue)(account));
+    const reader = (0, import_vue29.toValue)(client);
+    const address = (0, import_connect_appkit_core14.bareEvmAddress)((0, import_vue29.toValue)(account));
     if (!reader || !address) {
       guard.reset();
       balance.value = null;
@@ -1975,11 +2038,11 @@ function useBalance(account, client, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  (0, import_vue28.watch)(
+  (0, import_vue29.watch)(
     [
-      () => (0, import_vue28.toValue)(account),
-      () => (0, import_vue28.toValue)(client),
-      () => (0, import_vue28.toValue)(options.refreshInterval) ?? 0
+      () => (0, import_vue29.toValue)(account),
+      () => (0, import_vue29.toValue)(client),
+      () => (0, import_vue29.toValue)(options.refreshInterval) ?? 0
     ],
     ([, , interval]) => {
       stopTimer();
@@ -1988,13 +2051,13 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue28.onScopeDispose)(stopTimer);
+  (0, import_vue29.onScopeDispose)(stopTimer);
   return {
     balance,
-    formatted: (0, import_vue28.computed)(
-      () => balance.value === null ? null : (0, import_connect_core11.formatUnits)(BigInt(balance.value), (0, import_vue28.toValue)(options.decimals) ?? 18)
+    formatted: (0, import_vue29.computed)(
+      () => balance.value === null ? null : (0, import_connect_core12.formatUnits)(BigInt(balance.value), (0, import_vue29.toValue)(options.decimals) ?? 18)
     ),
-    symbol: (0, import_vue28.computed)(() => (0, import_vue28.toValue)(options.symbol) ?? null),
+    symbol: (0, import_vue29.computed)(() => (0, import_vue29.toValue)(options.symbol) ?? null),
     isFetching,
     error: guard.error,
     refetch
@@ -2003,11 +2066,11 @@ function useBalance(account, client, options = {}) {
 
 // src/useRouteQuote.ts
 var import_connect_appkit_core15 = require("@naculus/connect-appkit-core");
-var import_vue29 = require("vue");
+var import_vue30 = require("vue");
 function useRouteQuote(input, getQuotes, options = {}) {
   const guard = useActionGuard();
-  const quotes = (0, import_vue29.shallowRef)([]);
-  const loading = (0, import_vue29.shallowRef)(false);
+  const quotes = (0, import_vue30.shallowRef)([]);
+  const loading = (0, import_vue30.shallowRef)(false);
   let timer = null;
   const clearTimer = () => {
     if (timer) clearTimeout(timer);
@@ -2020,7 +2083,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
       quotes.value = [];
       return null;
     }
-    const fn = (0, import_vue29.unref)(getQuotes);
+    const fn = (0, import_vue30.unref)(getQuotes);
     if (!fn) {
       guard.invalidate();
       loading.value = false;
@@ -2029,7 +2092,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     return fn;
   };
   const fetchQuotes = async () => {
-    const current = (0, import_vue29.toValue)(input);
+    const current = (0, import_vue30.toValue)(input);
     const fn = requestable(current);
     if (!fn) return;
     loading.value = true;
@@ -2064,19 +2127,19 @@ function useRouteQuote(input, getQuotes, options = {}) {
     ).catch(() => {
     });
   };
-  (0, import_vue29.watch)(
+  (0, import_vue30.watch)(
     [
-      () => (0, import_vue29.toValue)(input).fromChain,
-      () => (0, import_vue29.toValue)(input).toChain,
-      () => (0, import_vue29.toValue)(input).fromToken,
-      () => (0, import_vue29.toValue)(input).toToken,
-      () => (0, import_vue29.toValue)(input).amount,
-      () => (0, import_vue29.unref)(getQuotes)
+      () => (0, import_vue30.toValue)(input).fromChain,
+      () => (0, import_vue30.toValue)(input).toChain,
+      () => (0, import_vue30.toValue)(input).fromToken,
+      () => (0, import_vue30.toValue)(input).toToken,
+      () => (0, import_vue30.toValue)(input).amount,
+      () => (0, import_vue30.unref)(getQuotes)
     ],
     () => {
       clearTimer();
       guard.invalidate();
-      if (!requestable((0, import_vue29.toValue)(input))) return;
+      if (!requestable((0, import_vue30.toValue)(input))) return;
       timer = setTimeout(() => {
         timer = null;
         void fetchQuotes();
@@ -2084,7 +2147,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue29.onScopeDispose)(clearTimer);
+  (0, import_vue30.onScopeDispose)(clearTimer);
   return {
     quotes,
     loading,
@@ -2101,14 +2164,14 @@ function useRouteQuote(input, getQuotes, options = {}) {
 
 // src/useCompareCosts.ts
 var import_connect_appkit_core16 = require("@naculus/connect-appkit-core");
-var import_vue30 = require("vue");
+var import_vue31 = require("vue");
 function useCompareCosts(input, compareCosts) {
   const guard = useActionGuard();
-  const comparisons = (0, import_vue30.shallowRef)([]);
-  const loading = (0, import_vue30.shallowRef)(false);
+  const comparisons = (0, import_vue31.shallowRef)([]);
+  const loading = (0, import_vue31.shallowRef)(false);
   const fetchComparisons = async () => {
-    const { operation, chains, options } = (0, import_vue30.toValue)(input);
-    const fn = (0, import_vue30.unref)(compareCosts);
+    const { operation, chains, options } = (0, import_vue31.toValue)(input);
+    const fn = (0, import_vue31.unref)(compareCosts);
     if (!chains || chains.length === 0) {
       guard.invalidate();
       loading.value = false;
@@ -2145,8 +2208,8 @@ function useCompareCosts(input, compareCosts) {
     ).catch(() => {
     });
   };
-  (0, import_vue30.watch)(
-    [() => (0, import_connect_appkit_core16.compareCostsKey)((0, import_vue30.toValue)(input)), () => (0, import_vue30.unref)(compareCosts)],
+  (0, import_vue31.watch)(
+    [() => (0, import_connect_appkit_core16.compareCostsKey)((0, import_vue31.toValue)(input)), () => (0, import_vue31.unref)(compareCosts)],
     () => {
       void fetchComparisons();
     },
@@ -2162,15 +2225,15 @@ function useCompareCosts(input, compareCosts) {
 
 // src/useExecuteRoute.ts
 var import_connect_appkit_core17 = require("@naculus/connect-appkit-core");
-var import_vue31 = require("vue");
+var import_vue32 = require("vue");
 function useExecuteRoute(executeRoute) {
-  const executing = (0, import_vue31.shallowRef)(false);
-  const result = (0, import_vue31.shallowRef)(null);
-  const error = (0, import_vue31.shallowRef)(null);
+  const executing = (0, import_vue32.shallowRef)(false);
+  const result = (0, import_vue32.shallowRef)(null);
+  const error = (0, import_vue32.shallowRef)(null);
   let inFlight = false;
   let disposed = false;
   const execute = async (quote, recipient, options) => {
-    const fn = (0, import_vue31.unref)(executeRoute);
+    const fn = (0, import_vue32.unref)(executeRoute);
     if (!fn) {
       error.value = {
         code: "no_executor",
@@ -2208,7 +2271,7 @@ function useExecuteRoute(executeRoute) {
       if (!disposed) executing.value = false;
     }
   };
-  (0, import_vue31.onScopeDispose)(() => {
+  (0, import_vue32.onScopeDispose)(() => {
     disposed = true;
   });
   return {
@@ -2226,18 +2289,18 @@ function useExecuteRoute(executeRoute) {
 
 // src/useTokenList.ts
 var import_connect_appkit_core18 = require("@naculus/connect-appkit-core");
-var import_connect_core12 = require("@naculus/connect-core");
-var import_vue32 = require("vue");
+var import_connect_core13 = require("@naculus/connect-core");
+var import_vue33 = require("vue");
 function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
-  const manager = options.manager ?? new import_connect_core12.TokenListManager(config);
+  const manager = options.manager ?? new import_connect_core13.TokenListManager(config);
   const guard = useActionGuard();
-  const tokens = (0, import_vue32.shallowRef)([]);
-  const isLoading = (0, import_vue32.shallowRef)(options.autoLoad !== false);
-  const isLoaded = (0, import_vue32.shallowRef)(false);
+  const tokens = (0, import_vue33.shallowRef)([]);
+  const isLoading = (0, import_vue33.shallowRef)(options.autoLoad !== false);
+  const isLoaded = (0, import_vue33.shallowRef)(false);
   const select = () => {
-    const id = (0, import_vue32.toValue)(chainId);
+    const id = (0, import_vue33.toValue)(chainId);
     const numeric = id ? (0, import_connect_appkit_core18.eip155ChainIdToNumber)(id) : void 0;
     return manager.getTokens(
       numeric !== void 0 ? { chainId: numeric } : void 0
@@ -2263,8 +2326,8 @@ function useTokenList(chainId, options = {}) {
     ).catch(() => {
     });
   };
-  (0, import_vue32.watch)(
-    () => (0, import_vue32.toValue)(chainId),
+  (0, import_vue33.watch)(
+    () => (0, import_vue33.toValue)(chainId),
     () => {
       if (options.autoLoad !== false) void run(() => manager.load());
     },
@@ -2281,29 +2344,29 @@ function useTokenList(chainId, options = {}) {
 
 // src/useTokenSearch.ts
 var import_connect_appkit_core19 = require("@naculus/connect-appkit-core");
-var import_connect_core13 = require("@naculus/connect-core");
-var import_vue33 = require("vue");
+var import_connect_core14 = require("@naculus/connect-core");
+var import_vue34 = require("vue");
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
 function getSharedManager() {
   if (!sharedManager) {
-    sharedManager = new import_connect_core13.TokenListManager();
+    sharedManager = new import_connect_core14.TokenListManager();
     sharedManager.load().catch(() => {
     });
   }
   return sharedManager;
 }
 function useTokenSearch(query, chainId, options = {}) {
-  const results = (0, import_vue33.shallowRef)(EMPTY);
-  const isSearching = (0, import_vue33.shallowRef)(false);
+  const results = (0, import_vue34.shallowRef)(EMPTY);
+  const isSearching = (0, import_vue34.shallowRef)(false);
   let timer = null;
   const clear = () => {
     if (timer) clearTimeout(timer);
     timer = null;
   };
-  (0, import_vue33.watch)(
-    [() => ((0, import_vue33.toValue)(query) ?? "").trim(), () => (0, import_vue33.toValue)(chainId)],
+  (0, import_vue34.watch)(
+    [() => ((0, import_vue34.toValue)(query) ?? "").trim(), () => (0, import_vue34.toValue)(chainId)],
     ([q, id]) => {
       clear();
       if (!q) {
@@ -2325,35 +2388,35 @@ function useTokenSearch(query, chainId, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue33.onScopeDispose)(clear);
+  (0, import_vue34.onScopeDispose)(clear);
   return { results, isSearching };
 }
 
 // src/useValidateDestination.ts
 var import_connect_appkit_core20 = require("@naculus/connect-appkit-core");
-var import_vue34 = require("vue");
+var import_vue35 = require("vue");
 function useValidateDestination(address) {
   return {
-    validation: (0, import_vue34.computed)(() => (0, import_connect_appkit_core20.validateDestination)((0, import_vue34.toValue)(address) ?? ""))
+    validation: (0, import_vue35.computed)(() => (0, import_connect_appkit_core20.validateDestination)((0, import_vue35.toValue)(address) ?? ""))
   };
 }
 
 // src/useTokenBalance.ts
 var import_connect_appkit_core21 = require("@naculus/connect-appkit-core");
-var import_connect_core14 = require("@naculus/connect-core");
-var import_vue35 = require("vue");
+var import_connect_core15 = require("@naculus/connect-core");
+var import_vue36 = require("vue");
 function tokensKey(tokens) {
   return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
 }
 function useTokenBalance(account, client, tokens, options = {}) {
   const guard = useActionGuard();
-  const tokenBalances = (0, import_vue35.shallowRef)([]);
-  const isFetching = (0, import_vue35.shallowRef)(false);
+  const tokenBalances = (0, import_vue36.shallowRef)([]);
+  const isFetching = (0, import_vue36.shallowRef)(false);
   let timer = null;
   const refetch = async () => {
-    const reader = (0, import_vue35.toValue)(client);
-    const address = (0, import_connect_appkit_core21.bareEvmAddress)((0, import_vue35.toValue)(account));
-    const list = (0, import_vue35.toValue)(tokens) ?? [];
+    const reader = (0, import_vue36.toValue)(client);
+    const address = (0, import_connect_appkit_core21.bareEvmAddress)((0, import_vue36.toValue)(account));
+    const list = (0, import_vue36.toValue)(tokens) ?? [];
     if (!reader || !address || list.length === 0) {
       guard.reset();
       tokenBalances.value = [];
@@ -2369,7 +2432,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
               try {
                 const raw = await reader.readContract({
                   address: token.address,
-                  abi: import_connect_core14.ERC20_MIN_ABI,
+                  abi: import_connect_core15.ERC20_MIN_ABI,
                   functionName: "balanceOf",
                   args: [address]
                 });
@@ -2377,7 +2440,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
                 return {
                   ...token,
                   balance: value.toString(),
-                  formatted: (0, import_connect_core14.formatUnits)(value, token.decimals)
+                  formatted: (0, import_connect_core15.formatUnits)(value, token.decimals)
                 };
               } catch {
                 return { ...token, balance: null, formatted: null };
@@ -2408,12 +2471,12 @@ function useTokenBalance(account, client, tokens, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  (0, import_vue35.watch)(
+  (0, import_vue36.watch)(
     [
-      () => (0, import_vue35.toValue)(account),
-      () => (0, import_vue35.toValue)(client),
-      () => tokensKey((0, import_vue35.toValue)(tokens) ?? []),
-      () => (0, import_vue35.toValue)(options.refreshInterval) ?? 0
+      () => (0, import_vue36.toValue)(account),
+      () => (0, import_vue36.toValue)(client),
+      () => tokensKey((0, import_vue36.toValue)(tokens) ?? []),
+      () => (0, import_vue36.toValue)(options.refreshInterval) ?? 0
     ],
     ([, , , interval]) => {
       stopTimer();
@@ -2422,7 +2485,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue35.onScopeDispose)(stopTimer);
+  (0, import_vue36.onScopeDispose)(stopTimer);
   return {
     tokenBalances,
     isFetching,
@@ -2436,12 +2499,12 @@ function useTokenBalance(account, client, tokens, options = {}) {
 
 // src/useDelegate.ts
 var import_connect_appkit_core22 = require("@naculus/connect-appkit-core");
-var import_connect_core15 = require("@naculus/connect-core");
-var import_vue36 = require("vue");
+var import_connect_core16 = require("@naculus/connect-core");
+var import_vue37 = require("vue");
 function useDelegate(options) {
-  const result = (0, import_vue36.shallowRef)(null);
-  const isPending = (0, import_vue36.shallowRef)(false);
-  const error = (0, import_vue36.shallowRef)(null);
+  const result = (0, import_vue37.shallowRef)(null);
+  const isPending = (0, import_vue37.shallowRef)(false);
+  const error = (0, import_vue37.shallowRef)(null);
   let requestId = 0;
   let inFlight = false;
   let disposed = false;
@@ -2451,31 +2514,31 @@ function useDelegate(options) {
   };
   const run = async (target, allowlist) => {
     if (inFlight) return fail(new Error("A delegation is already in progress"));
-    const session = (0, import_vue36.toValue)(options.session);
-    const account = (0, import_connect_appkit_core22.bareEvmAddress)((0, import_vue36.toValue)(options.account));
-    const chainId = (0, import_vue36.toValue)(options.chainId);
+    const session = (0, import_vue37.toValue)(options.session);
+    const account = (0, import_connect_appkit_core22.bareEvmAddress)((0, import_vue37.toValue)(options.account));
+    const chainId = (0, import_vue37.toValue)(options.chainId);
     if (!session || !account || !chainId) {
       return fail(
-        new import_connect_core15.WalletError("wallet_unavailable", "No connected EVM account")
+        new import_connect_core16.WalletError("wallet_unavailable", "No connected EVM account")
       );
     }
-    const reader = (0, import_vue36.toValue)(options.client);
-    if (!reader || reader.chain?.id !== (0, import_connect_core15.eip155Reference)(chainId)) {
+    const reader = (0, import_vue37.toValue)(options.client);
+    if (!reader || reader.chain?.id !== (0, import_connect_core16.eip155Reference)(chainId)) {
       return fail(
-        new import_connect_core15.WalletError(
+        new import_connect_core16.WalletError(
           "chain_mismatch",
           `No RPC client for ${chainId}; refusing to read the nonce elsewhere.`
         )
       );
     }
-    const connector = (0, import_vue36.toValue)(options.connector) ?? {};
+    const connector = (0, import_vue37.toValue)(options.connector) ?? {};
     const own = ++requestId;
     inFlight = true;
     isPending.value = true;
     error.value = null;
     result.value = null;
     try {
-      const sent = await (0, import_connect_core15.delegateAccount)({
+      const sent = await (0, import_connect_core16.delegateAccount)({
         connector,
         session,
         account,
@@ -2503,22 +2566,22 @@ function useDelegate(options) {
     isPending.value = false;
     error.value = null;
   };
-  (0, import_vue36.watch)(
+  (0, import_vue37.watch)(
     [
-      () => (0, import_vue36.toValue)(options.session),
-      () => (0, import_vue36.toValue)(options.account),
-      () => (0, import_vue36.toValue)(options.chainId)
+      () => (0, import_vue37.toValue)(options.session),
+      () => (0, import_vue37.toValue)(options.account),
+      () => (0, import_vue37.toValue)(options.chainId)
     ],
     reset,
     { flush: "sync" }
   );
-  (0, import_vue36.onScopeDispose)(() => {
+  (0, import_vue37.onScopeDispose)(() => {
     disposed = true;
     requestId++;
   });
   return {
-    delegate: (target) => run(target, (0, import_vue36.toValue)(options.allowlist)),
-    revoke: () => run(import_connect_core15.REVOKE_DELEGATE, []),
+    delegate: (target) => run(target, (0, import_vue37.toValue)(options.allowlist)),
+    revoke: () => run(import_connect_core16.REVOKE_DELEGATE, []),
     result,
     isPending,
     error,
@@ -2528,16 +2591,16 @@ function useDelegate(options) {
 
 // src/useDelegation.ts
 var import_connect_appkit_core23 = require("@naculus/connect-appkit-core");
-var import_connect_core16 = require("@naculus/connect-core");
-var import_vue37 = require("vue");
+var import_connect_core17 = require("@naculus/connect-core");
+var import_vue38 = require("vue");
 function useDelegation(account, client, chainId) {
   const guard = useActionGuard();
-  const status = (0, import_vue37.shallowRef)(import_connect_core16.UNKNOWN_DELEGATION);
-  const isFetching = (0, import_vue37.shallowRef)(false);
+  const status = (0, import_vue38.shallowRef)(import_connect_core17.UNKNOWN_DELEGATION);
+  const isFetching = (0, import_vue38.shallowRef)(false);
   const refetch = async () => {
-    const reader = (0, import_vue37.toValue)(client);
-    const address = (0, import_connect_appkit_core23.bareEvmAddress)((0, import_vue37.toValue)(account));
-    status.value = import_connect_core16.UNKNOWN_DELEGATION;
+    const reader = (0, import_vue38.toValue)(client);
+    const address = (0, import_connect_appkit_core23.bareEvmAddress)((0, import_vue38.toValue)(account));
+    status.value = import_connect_core17.UNKNOWN_DELEGATION;
     if (!reader || !address) {
       guard.reset();
       isFetching.value = false;
@@ -2549,11 +2612,11 @@ function useDelegation(account, client, chainId) {
         try {
           const code = await reader.getCode({ address });
           commit(() => {
-            status.value = (0, import_connect_core16.readDelegation)(code ?? "0x");
+            status.value = (0, import_connect_core17.readDelegation)(code ?? "0x");
           });
         } catch (cause) {
           commit(() => {
-            status.value = import_connect_core16.UNKNOWN_DELEGATION;
+            status.value = import_connect_core17.UNKNOWN_DELEGATION;
           });
           throw cause;
         }
@@ -2568,16 +2631,16 @@ function useDelegation(account, client, chainId) {
     ).catch(() => {
     });
   };
-  (0, import_vue37.watch)(
-    [() => (0, import_vue37.toValue)(account), () => (0, import_vue37.toValue)(client), () => (0, import_vue37.toValue)(chainId)],
+  (0, import_vue38.watch)(
+    [() => (0, import_vue38.toValue)(account), () => (0, import_vue38.toValue)(client), () => (0, import_vue38.toValue)(chainId)],
     () => {
       void refetch();
     },
     { immediate: true, flush: "sync" }
   );
   return {
-    delegated: (0, import_vue37.computed)(() => status.value.delegated),
-    delegate: (0, import_vue37.computed)(() => status.value.delegate),
+    delegated: (0, import_vue38.computed)(() => status.value.delegated),
+    delegate: (0, import_vue38.computed)(() => status.value.delegate),
     isFetching,
     error: guard.error,
     refetch
@@ -2586,21 +2649,61 @@ function useDelegation(account, client, chainId) {
 
 // src/usePaymentFetch.ts
 var import_connect_appkit_core24 = require("@naculus/connect-appkit-core");
-var import_vue38 = require("vue");
-function usePaymentFetch(pay) {
+var import_vue39 = require("vue");
+function usePaymentFetch(pay, options = {}) {
   const guard = useActionGuard();
-  const lastPayment = (0, import_vue38.shallowRef)(null);
+  const lastPayment = (0, import_vue39.shallowRef)(null);
   let epoch = 0;
-  (0, import_vue38.onScopeDispose)(() => {
+  let verification = 0;
+  (0, import_vue39.onScopeDispose)(() => {
     epoch++;
+    verification++;
   });
   const payFetch = (input, init) => {
-    const invoke = (0, import_vue38.unref)(pay);
+    const invoke = (0, import_vue39.unref)(pay);
     const own = epoch;
     return guard.run(async () => {
       const result = await invoke(input, init);
-      const payment = (0, import_connect_appkit_core24.describePayment)(input, result);
-      if (payment && own === epoch) lastPayment.value = payment;
+      let payment = (0, import_connect_appkit_core24.describePayment)(input, result);
+      if (payment && own === epoch) {
+        const verify = options.verify;
+        if (!verify) {
+          lastPayment.value = payment;
+        } else {
+          payment = (0, import_connect_appkit_core24.applySettlementVerification)(payment, { status: "pending" });
+          lastPayment.value = payment;
+          const verificationOwn = ++verification;
+          const retry = options.verifyRetry ?? import_connect_appkit_core24.DEFAULT_VERIFY_RETRY;
+          void Promise.resolve().then(async () => {
+            let outcome = { status: "pending" };
+            for (let attempt = 0; attempt < retry.attempts; attempt += 1) {
+              if (attempt > 0) {
+                await new Promise(
+                  (resolve) => setTimeout(resolve, retry.delayMs)
+                );
+              }
+              if (own !== epoch || verificationOwn !== verification) return;
+              try {
+                outcome = await verify(result);
+              } catch (cause) {
+                outcome = {
+                  status: "unavailable",
+                  reason: cause instanceof Error ? cause.message : "Settlement verification failed"
+                };
+              }
+              if (outcome.status !== "pending") break;
+            }
+            if (own === epoch && verificationOwn === verification) {
+              const current = lastPayment.value;
+              if (current)
+                lastPayment.value = (0, import_connect_appkit_core24.applySettlementVerification)(
+                  current,
+                  outcome
+                );
+            }
+          });
+        }
+      }
       return result;
     }, "Paid request failed");
   };
@@ -2611,22 +2714,150 @@ function usePaymentFetch(pay) {
     error: guard.error,
     reset: () => {
       epoch++;
+      verification++;
       guard.reset();
       lastPayment.value = null;
     }
   };
 }
 
-// src/useSolanaSessionKey.ts
+// src/useMppSession.ts
 var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
-var import_vue39 = require("vue");
+var import_vue40 = require("vue");
+function useMppSession(session) {
+  const current = () => (0, import_vue40.unref)(session);
+  const pending = (0, import_vue40.shallowRef)(current().meter.pending);
+  const channel = (0, import_vue40.shallowRef)(
+    (0, import_connect_appkit_core25.readCurrentMppSessionChannel)(current())
+  );
+  const lastReceipt = (0, import_vue40.shallowRef)(null);
+  const recoveryChannelId = (0, import_vue40.shallowRef)(null);
+  const isPending = (0, import_vue40.shallowRef)(false);
+  const error = (0, import_vue40.shallowRef)(null);
+  let active = 0;
+  let generation = 0;
+  let epoch = 0;
+  let disposed = false;
+  (0, import_vue40.watch)(
+    () => (0, import_vue40.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_vue40.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_vue41 = require("vue");
 function useSolanaSessionKey(deps) {
   const guard = useActionGuard();
-  const keys = (0, import_vue39.shallowRef)([]);
+  const keys = (0, import_vue41.shallowRef)([]);
   let flow = null;
   let generation = 0;
   let disposed = false;
-  (0, import_vue39.onScopeDispose)(() => {
+  (0, import_vue41.onScopeDispose)(() => {
     disposed = true;
   });
   const refresh = async () => {
@@ -2634,10 +2865,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_vue41.watch)(
+    () => (0, import_vue41.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 +2899,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_vue42 = 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_vue42.shallowRef)(null);
+  const loading = (0, import_vue42.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_vue42.toValue)(options.input).trim();
+    const skip = (0, import_vue42.toValue)(options.skip) ?? false;
+    const scope = (0, import_vue42.toValue)(options.scope);
+    const config = (0, import_vue42.toValue)(options.resolverConfig);
     if (!input || skip) {
       guard.reset();
       data.value = null;
@@ -2691,7 +2922,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 +2944,19 @@ function useNameLookup(options) {
     ).catch(() => {
     });
   };
-  (0, import_vue40.watch)(
+  (0, import_vue42.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_vue42.toValue)(options.input),
+      (0, import_vue42.toValue)(options.skip),
+      (0, import_vue42.toValue)(options.scope),
+      (0, import_vue42.toValue)(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
   return {
     data,
-    isLoading: (0, import_vue40.computed)(() => loading.value),
+    isLoading: (0, import_vue42.computed)(() => loading.value),
     error: guard.error,
     refetch: run
   };
@@ -2753,21 +2984,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-var import_vue41 = require("vue");
+var import_vue43 = 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_vue43.computed)(() => (0, import_vue43.toValue)(connected));
+  const caip10 = (0, import_vue43.computed)(
+    () => isConnected.value ? ((0, import_vue43.toValue)(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
-  const parts = (0, import_vue41.computed)(() => caip10.value?.split(":") ?? []);
+  const parts = (0, import_vue43.computed)(() => caip10.value?.split(":") ?? []);
   return {
-    address: (0, import_vue41.computed)(
+    address: (0, import_vue43.computed)(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: (0, import_vue41.computed)(
+    chainId: (0, import_vue43.computed)(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -2775,35 +3006,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_vue44 = 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_vue44.computed)(() => (0, import_vue44.toValue)(chains) ?? []);
+  const id = (0, import_vue44.computed)(() => (0, import_vue44.toValue)(chainId) ?? null);
+  const currentChain = (0, import_vue44.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_vue44.computed)(() => (0, import_connect_appkit_core28.describeChain)(list.value, id.value)),
+    availableChains: (0, import_vue44.computed)(() => (0, import_connect_appkit_core28.chainsForNamespace)(list.value, id.value)),
+    currentChainNumber: (0, import_vue44.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_vue44.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core28.chainNamespace)(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-var import_vue43 = require("vue");
+var import_vue45 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue43.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue45.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue43.onScopeDispose)(unsubscribe);
+  (0, import_vue45.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue43.readonly)(request),
+    request: (0, import_vue45.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -2811,15 +3042,15 @@ function usePassphraseGate(gate) {
 }
 
 // src/useSolanaBalance.ts
-var import_connect_core17 = require("@naculus/connect-core");
-var import_vue44 = require("vue");
+var import_connect_core18 = require("@naculus/connect-core");
+var import_vue46 = 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_vue46.shallowRef)(null);
+  const isFetching = (0, import_vue46.ref)(false);
   const refetch = async () => {
-    const addr = (0, import_vue44.toValue)(address);
-    const url = (0, import_vue44.toValue)(rpcUrl);
+    const addr = (0, import_vue46.toValue)(address);
+    const url = (0, import_vue46.toValue)(rpcUrl);
     if (!addr || !url) {
       guard.invalidate();
       isFetching.value = false;
@@ -2830,7 +3061,7 @@ function useSolanaBalance(address, rpcUrl) {
     await guard.run(
       async (commit) => {
         try {
-          const next = await (0, import_connect_core17.getSolanaBalance)(url, addr);
+          const next = await (0, import_connect_core18.getSolanaBalance)(url, addr);
           commit(() => {
             balance.value = next;
           });
@@ -2851,22 +3082,22 @@ function useSolanaBalance(address, rpcUrl) {
     ).catch(() => {
     });
   };
-  (0, import_vue44.watchEffect)(() => {
-    (0, import_vue44.toValue)(address);
-    (0, import_vue44.toValue)(rpcUrl);
+  (0, import_vue46.watchEffect)(() => {
+    (0, import_vue46.toValue)(address);
+    (0, import_vue46.toValue)(rpcUrl);
     void refetch();
   });
   return { balance, isFetching, error: guard.error, refetch };
 }
 
 // src/useLastTx.ts
-var import_vue45 = require("vue");
+var import_vue47 = 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_vue47.shallowRef)(null);
+  const lastConfirmedTx = (0, import_vue47.shallowRef)(null);
+  const lastFailedTx = (0, import_vue47.shallowRef)(null);
+  (0, import_vue47.watch)(
+    () => (0, import_vue47.toValue)(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -2904,13 +3135,13 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-var import_vue46 = require("vue");
+var import_vue48 = 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_vue48.shallowRef)([]);
+  const isLoading = (0, import_vue48.shallowRef)(false);
   const refresh = async () => {
-    const activeMonitor = (0, import_vue46.toValue)(monitor);
+    const activeMonitor = (0, import_vue48.toValue)(monitor);
     if (!activeMonitor) {
       guard.reset();
       entries.value = [];
@@ -2921,8 +3152,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_vue48.toValue)(address) ?? void 0,
+          (0, import_vue48.toValue)(chainId) ?? void 0
         );
         commit(() => {
           entries.value = result;
@@ -2938,8 +3169,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_vue48.watch)(
+    [() => (0, import_vue48.toValue)(monitor), () => (0, import_vue48.toValue)(address), () => (0, import_vue48.toValue)(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -2959,7 +3190,7 @@ function useTxHistory(address, chainId, monitor) {
     isLoading,
     error: guard.error,
     refresh,
-    summary: (0, import_vue46.computed)(() => ({
+    summary: (0, import_vue48.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,25 +3199,25 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-var import_vue47 = require("vue");
+var import_vue49 = 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 entry = (0, import_vue49.shallowRef)(null);
+  const isLoading = (0, import_vue49.shallowRef)(false);
+  const isWatching = (0, import_vue49.shallowRef)(false);
   const guard = useActionGuard();
   const error = guard.error;
   let generation = 0;
   let refreshed = [];
   const currentInputs = () => [
-    (0, import_vue47.toValue)(monitor),
-    (0, import_vue47.toValue)(hash),
-    (0, import_vue47.toValue)(chainId)
+    (0, import_vue49.toValue)(monitor),
+    (0, import_vue49.toValue)(hash),
+    (0, import_vue49.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_vue49.toValue)(monitor);
+    const activeHash = (0, import_vue49.toValue)(hash);
+    const activeChainId = (0, import_vue49.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     const started = [activeMonitor, activeHash, activeChainId];
     refreshed = started;
@@ -3022,15 +3253,15 @@ function useTxMonitor(hash, chainId, monitor) {
     });
   };
   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_vue49.toValue)(monitor);
+    const activeHash = (0, import_vue49.toValue)(hash);
+    const activeChainId = (0, import_vue49.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_vue49.watch)(
+    [() => (0, import_vue49.toValue)(monitor), () => (0, import_vue49.toValue)(hash), () => (0, import_vue49.toValue)(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
       if (!sameInputs([activeMonitor, activeHash, activeChainId], refreshed)) {
@@ -3072,7 +3303,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: (0, import_vue47.computed)(() => entry.value?.status ?? "idle"),
+    status: (0, import_vue49.computed)(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -3082,17 +3313,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_vue50 = require("vue");
 function useCapabilities(client, session, chainId) {
   const guard = useActionGuard();
-  const capabilities = (0, import_vue48.shallowRef)(
+  const capabilities = (0, import_vue50.shallowRef)(
     null
   );
-  const isFetching = (0, import_vue48.shallowRef)(false);
+  const isFetching = (0, import_vue50.shallowRef)(false);
   const refetch = async () => {
-    const activeClient = (0, import_vue48.toValue)(client);
-    const activeSession = (0, import_vue48.toValue)(session);
+    const activeClient = (0, import_vue50.toValue)(client);
+    const activeSession = (0, import_vue50.toValue)(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       guard.reset();
       capabilities.value = null;
@@ -3105,7 +3336,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(() => {
@@ -3124,18 +3355,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_vue50.watchEffect)(() => {
+    void (0, import_vue50.toValue)(client);
+    void (0, import_vue50.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_vue50.computed)(
+      () => (0, import_connect_appkit_core29.selectChainCapabilities)(capabilities.value, (0, import_vue50.toValue)(chainId))
     ),
-    atomic: (0, import_vue48.computed)(
-      () => (0, import_connect_appkit_core28.atomicSupportFor)(capabilities.value, (0, import_vue48.toValue)(chainId))
+    atomic: (0, import_vue50.computed)(
+      () => (0, import_connect_appkit_core29.atomicSupportFor)(capabilities.value, (0, import_vue50.toValue)(chainId))
     ),
     isFetching,
     error: guard.error,
@@ -3144,18 +3375,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_vue51 = 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_vue51.computed)(
+    () => (0, import_connect_appkit_core30.readSolanaRoles)((0, import_vue51.toValue)(connector), (0, import_vue51.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_vue51.computed)(() => state.value.roles),
+    absence: (0, import_vue51.computed)(() => state.value.absence),
+    identity: (0, import_vue51.computed)(() => state.value.roles?.identity ?? null),
+    signer: (0, import_vue51.computed)(() => state.value.roles?.signer ?? null),
+    payer: (0, import_vue51.computed)(() => state.value.roles?.payer ?? null)
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3190,6 +3421,7 @@ function useSolanaRoles(connector, session) {
   AppkitTooltip,
   useAccount,
   useAccounts,
+  useAuthorizations,
   useBalance,
   useCapabilities,
   useChain,
@@ -3208,6 +3440,7 @@ function useSolanaRoles(connector, session) {
   useExecuteRoute,
   useLastTx,
   useLookupAddress,
+  useMppSession,
   useNotification,
   usePassphraseGate,
   usePaymentFetch,