@naculus/connect-appkit-vue 0.6.0 → 0.8.0

package/dist/index.js

@@ -209,6 +209,55 @@ function useAccounts(accounts) {
   };
 }
 
+// src/useAuthorizations.ts
+import {
+  listAuthorizations,
+  revokeListedAuthorization
+} from "@naculus/connect-core";
+import { onScopeDispose, shallowRef, unref, watch } from "vue";
+function useAuthorizations({
+  managers
+}) {
+  const entries = shallowRef([]);
+  const loading = shallowRef(false);
+  const error = shallowRef(null);
+  let generation = 0;
+  let disposed = false;
+  const refresh = async () => {
+    const own = ++generation;
+    loading.value = true;
+    error.value = null;
+    try {
+      const next = await listAuthorizations(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 = watch(() => unref(managers), refresh, { immediate: true });
+  onScopeDispose(() => {
+    disposed = true;
+    generation += 1;
+    stop();
+  });
+  const revoke = async (entry) => {
+    try {
+      const result = await revokeListedAuthorization(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
 import {
   addInAppNotification,
@@ -219,40 +268,56 @@ import {
   loadNotificationSettings,
   mutedChainSettings,
   saveNotificationSettings,
+  replayNotificationSettings,
   updateNotificationSettings
 } from "@naculus/connect-appkit-core";
 import {
   InAppChannel
 } from "@naculus/connect-core";
-import { computed as computed2, onScopeDispose, shallowRef, unref } from "vue";
+import { computed as computed2, onScopeDispose as onScopeDispose2, shallowRef as shallowRef2, unref as unref2 } from "vue";
 function useNotification(options = {}) {
-  const channel = unref(options.channel) ?? new InAppChannel();
-  const storage = unref(options.storage) ?? createNotificationSettingsStorage();
-  const notifications = shallowRef(channel.getHistory());
-  const settings = shallowRef(
+  const channel = unref2(options.channel) ?? new InAppChannel();
+  const storage = unref2(options.storage) ?? createNotificationSettingsStorage();
+  const notifications = shallowRef2(channel.getHistory());
+  const settings = shallowRef2(
     DEFAULT_NOTIFICATION_SETTINGS
   );
   const unreadCount = computed2(
     () => notifications.value.filter((item) => !item.read).length
   );
   let disposed = false;
-  void 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 = replayNotificationSettings(saved, queued);
+    saveNotificationSettings(storage, settings.value);
+  };
+  void 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();
   });
-  onScopeDispose(() => {
+  onScopeDispose2(() => {
     disposed = true;
     channel.onNotification = void 0;
   });
-  const updateSettings = (update) => {
-    settings.value = updateNotificationSettings(settings.value, update);
+  const applySettings = (compute) => {
+    pending?.push(compute);
+    settings.value = updateNotificationSettings(
+      settings.value,
+      compute(settings.value)
+    );
     saveNotificationSettings(storage, settings.value);
   };
+  const updateSettings = (update) => applySettings(() => update);
   return {
     notifications,
     unreadCount,
@@ -282,8 +347,8 @@ function useNotification(options = {}) {
     },
     updateSettings,
     setChannels: (channels) => updateSettings(channelsUpdate(channels)),
-    muteChain: (chainId) => updateSettings(mutedChainSettings(settings.value, chainId, true)),
-    unmuteChain: (chainId) => updateSettings(mutedChainSettings(settings.value, chainId, false))
+    muteChain: (chainId) => applySettings((current) => mutedChainSettings(current, chainId, true)),
+    unmuteChain: (chainId) => applySettings((current) => mutedChainSettings(current, chainId, false))
   };
 }
 
@@ -292,13 +357,13 @@ import { resolveSimulationEndpoint } from "@naculus/connect-appkit-core";
 import {
   SimulationManager
 } from "@naculus/connect-core";
-import { shallowRef as shallowRef3, unref as unref2 } from "vue";
+import { shallowRef as shallowRef4, unref as unref3 } from "vue";
 
 // src/internal/action-guard.ts
-import { onScopeDispose as onScopeDispose2, shallowRef as shallowRef2 } from "vue";
+import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef3 } from "vue";
 function useActionGuard() {
-  const busy = shallowRef2(false);
-  const error = shallowRef2(null);
+  const busy = shallowRef3(false);
+  const error = shallowRef3(null);
   let active = 0;
   let generation = 0;
   let disposed = false;
@@ -339,24 +404,24 @@ function useActionGuard() {
     disposed = true;
     generation++;
   };
-  onScopeDispose2(dispose);
+  onScopeDispose3(dispose);
   return { busy, error, run, clearError, reset, invalidate, dispose };
 }
 
 // src/useSimulateTransfer.ts
 function useSimulateTransfer(options = {}) {
   const guard = useActionGuard();
-  const result = shallowRef3(null);
-  const loading = shallowRef3(false);
+  const result = shallowRef4(null);
+  const loading = shallowRef4(false);
   let manager;
   const simulate = async (tokenAddress, from, to, amount, callOptions) => {
     loading.value = true;
     return await guard.run(
       async (commit) => {
-        const fallbackRpcUrl = unref2(options.rpcUrl);
+        const fallbackRpcUrl = unref3(options.rpcUrl);
         const endpoint = resolveSimulationEndpoint(
           callOptions?.chainId,
-          unref2(options.chainId),
+          unref3(options.chainId),
           callOptions?.rpcUrl,
           fallbackRpcUrl
         );
@@ -400,11 +465,11 @@ function useSimulateTransfer(options = {}) {
 import {
   simulateTransactionPreview
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef4, toValue as toValue2, unref as unref3, watch } from "vue";
+import { onScopeDispose as onScopeDispose4, shallowRef as shallowRef5, toValue as toValue2, unref as unref4, watch as watch2 } from "vue";
 function useTransactionSimulation(tx, options = {}) {
   const guard = useActionGuard();
-  const result = shallowRef4(void 0);
-  const isSimulating = shallowRef4(false);
+  const result = shallowRef5(void 0);
+  const isSimulating = shallowRef5(false);
   let timer;
   const simulate = async () => {
     const transaction = toValue2(tx);
@@ -412,10 +477,10 @@ function useTransactionSimulation(tx, options = {}) {
     return await guard.run(
       async (commit) => {
         const value = await simulateTransactionPreview(transaction, {
-          chainId: unref3(options.chainId),
-          currentChain: unref3(options.currentChain),
-          publicClient: unref3(options.publicClient),
-          evmAccount: unref3(options.evmAccount)
+          chainId: unref4(options.chainId),
+          currentChain: unref4(options.currentChain),
+          publicClient: unref4(options.publicClient),
+          evmAccount: unref4(options.evmAccount)
         });
         commit(() => {
           result.value = value;
@@ -432,13 +497,13 @@ function useTransactionSimulation(tx, options = {}) {
       }
     );
   };
-  watch(
+  watch2(
     [
       () => toValue2(tx),
-      () => unref3(options.chainId),
-      () => unref3(options.currentChain),
-      () => unref3(options.publicClient),
-      () => unref3(options.evmAccount)
+      () => unref4(options.chainId),
+      () => unref4(options.currentChain),
+      () => unref4(options.publicClient),
+      () => unref4(options.evmAccount)
     ],
     ([transaction]) => {
       guard.invalidate();
@@ -460,7 +525,7 @@ function useTransactionSimulation(tx, options = {}) {
     result.value = void 0;
     isSimulating.value = false;
   };
-  onScopeDispose3(() => {
+  onScopeDispose4(() => {
     if (timer) clearTimeout(timer);
   });
   return { result, isSimulating, error: guard.error, simulate, reset };
@@ -478,7 +543,7 @@ import {
   parseUnits,
   WalletError as WalletError2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose4, shallowRef as shallowRef5, toValue as toValue3, unref as unref4, watch as watch2 } from "vue";
+import { onScopeDispose as onScopeDispose5, shallowRef as shallowRef6, toValue as toValue3, unref as unref5, watch as watch3 } from "vue";
 
 // src/erc20.ts
 import {
@@ -503,11 +568,11 @@ function assertErc20Context(token, chainId, account, connected) {
 function useERC20Transfer(options) {
   const initialToken = toValue3(options.token);
   const decimals = createDecimalsCache(initialToken, initialToken.decimals);
-  const isSending = shallowRef5(false);
-  const error = shallowRef5(null);
+  const isSending = shallowRef6(false);
+  const error = shallowRef6(null);
   let generation = 0;
   let disposed = false;
-  watch2(
+  watch3(
     [
       () => toValue3(options.token).address,
       () => toValue3(options.token).chainId,
@@ -516,7 +581,7 @@ function useERC20Transfer(options) {
       () => toValue3(options.chainId),
       () => toValue3(options.connected),
       () => toValue3(options.publicClient),
-      () => unref4(options.sendTransaction)
+      () => unref5(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -563,7 +628,7 @@ function useERC20Transfer(options) {
         writeDecimals(decimals, token, precision);
       }
       const data = encodeErc20Transfer(to, parseUnits(amount, precision));
-      return await unref4(options.sendTransaction)({
+      return await unref5(options.sendTransaction)({
         to: token.address,
         data,
         value: "0"
@@ -576,7 +641,7 @@ function useERC20Transfer(options) {
       if (stillCurrent()) isSending.value = false;
     }
   };
-  onScopeDispose4(() => {
+  onScopeDispose5(() => {
     disposed = true;
     generation++;
   });
@@ -598,24 +663,24 @@ import {
 } from "@naculus/connect-core";
 import {
   computed as computed3,
-  onScopeDispose as onScopeDispose5,
-  shallowRef as shallowRef6,
+  onScopeDispose as onScopeDispose6,
+  shallowRef as shallowRef7,
   toValue as toValue4,
-  unref as unref5,
-  watch as watch3
+  unref as unref6,
+  watch as watch4
 } from "vue";
 var MAX_UINT256 = (1n << 256n) - 1n;
 function useERC20Approve(options) {
   const initialToken = toValue4(options.token);
   const decimals = createDecimalsCache2(initialToken, initialToken.decimals);
-  const allowanceRaw = shallowRef6(null);
-  const isApproving = shallowRef6(false);
-  const isFetchingAllowance = shallowRef6(false);
-  const error = shallowRef6(null);
+  const allowanceRaw = shallowRef7(null);
+  const isApproving = shallowRef7(false);
+  const isFetchingAllowance = shallowRef7(false);
+  const error = shallowRef7(null);
   let generation = 0;
   let allowanceGeneration = 0;
   let disposed = false;
-  watch3(
+  watch4(
     [
       () => toValue4(options.token).address,
       () => toValue4(options.token).chainId,
@@ -625,7 +690,7 @@ function useERC20Approve(options) {
       () => toValue4(options.chainId),
       () => toValue4(options.connected),
       () => toValue4(options.publicClient),
-      () => unref5(options.sendTransaction)
+      () => unref6(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -699,7 +764,7 @@ function useERC20Approve(options) {
     isApproving.value = true;
     try {
       const { token, spender } = context();
-      const hash = await unref5(options.sendTransaction)({
+      const hash = await unref6(options.sendTransaction)({
         to: token.address,
         data: encodeErc20Approve(spender, rawAmount),
         value: "0"
@@ -746,7 +811,7 @@ function useERC20Approve(options) {
     const precision = readDecimals2(decimals, token, token.decimals);
     return precision === void 0 ? null : formatUnits(allowanceRaw.value, precision);
   });
-  onScopeDispose5(() => {
+  onScopeDispose6(() => {
     disposed = true;
     generation++;
     allowanceGeneration++;
@@ -832,7 +897,7 @@ function useAccount(accounts, connected) {
 }
 
 // src/useSession.ts
-import { computed as computed6, shallowRef as shallowRef7, toValue as toValue7, watch as watch4 } from "vue";
+import { computed as computed6, shallowRef as shallowRef8, toValue as toValue7, watch as watch5 } from "vue";
 function readSession(manager) {
   const bundle = manager?.getActiveBundle();
   if (!bundle) {
@@ -851,8 +916,8 @@ function readSession(manager) {
   };
 }
 function useSession(manager) {
-  const snapshot = shallowRef7(readSession(toValue7(manager)));
-  watch4(
+  const snapshot = shallowRef8(readSession(toValue7(manager)));
+  watch5(
     () => toValue7(manager),
     (current, _previous, onCleanup) => {
       const update = () => {
@@ -886,13 +951,13 @@ function useSession(manager) {
 
 // src/useConnect.ts
 import { WalletError as WalletError4 } from "@naculus/connect-core";
-import { computed as computed7, toValue as toValue8, unref as unref6 } from "vue";
+import { computed as computed7, toValue as toValue8, unref as unref7 } from "vue";
 function useConnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
   const connect = () => {
     if (inFlight) return inFlight;
-    const invoke = unref6(action);
+    const invoke = unref7(action);
     const pending = guard.run(
       () => Promise.resolve().then(() => invoke()),
       "Connection failed",
@@ -917,14 +982,14 @@ function useConnect(action, status) {
 }
 
 // src/useDisconnect.ts
-import { toValue as toValue9, unref as unref7 } from "vue";
+import { toValue as toValue9, unref as unref8 } from "vue";
 function useDisconnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
   const disconnect = () => {
     if (inFlight) return inFlight;
     if (toValue9(status) === "disconnected") return Promise.resolve();
-    const invoke = unref7(action);
+    const invoke = unref8(action);
     const pending = guard.run(() => Promise.resolve().then(() => invoke()), "Disconnect failed").catch(() => {
     }).finally(() => {
       if (inFlight === pending) inFlight = null;
@@ -945,11 +1010,11 @@ function useDisconnect(action, status) {
 
 // src/useSwitchChain.ts
 import { toChainSwitchError } from "@naculus/connect-appkit-core";
-import { computed as computed8, toValue as toValue10, unref as unref8 } from "vue";
+import { computed as computed8, toValue as toValue10, unref as unref9 } from "vue";
 function useSwitchChain(action, chainId) {
   const guard = useActionGuard();
   const switchChain = (targetChainId) => {
-    const invoke = unref8(action);
+    const invoke = unref9(action);
     return guard.run(async () => {
       try {
         await invoke(targetChainId);
@@ -968,11 +1033,11 @@ function useSwitchChain(action, chainId) {
 }
 
 // src/useSignMessage.ts
-import { unref as unref9 } from "vue";
+import { unref as unref10 } from "vue";
 function useSignMessage(action) {
   const guard = useActionGuard();
   const signMessage = (message) => {
-    const invoke = unref9(action);
+    const invoke = unref10(action);
     return guard.run(() => invoke(message), "Signing failed");
   };
   return {
@@ -984,12 +1049,12 @@ function useSignMessage(action) {
 }
 
 // src/useSendTransaction.ts
-import { computed as computed9, shallowRef as shallowRef8, unref as unref10 } from "vue";
+import { computed as computed9, shallowRef as shallowRef9, unref as unref11 } from "vue";
 function useSendTransaction(action) {
   const guard = useActionGuard();
-  const status = shallowRef8("idle");
+  const status = shallowRef9("idle");
   const sendTransaction = (transaction) => {
-    const invoke = unref10(action);
+    const invoke = unref11(action);
     status.value = "awaiting_approval";
     return guard.run(async (commit) => {
       const hash = await invoke(transaction);
@@ -1016,15 +1081,15 @@ function useSendTransaction(action) {
 }
 
 // src/useSolanaTransaction.ts
-import { shallowRef as shallowRef9, unref as unref11 } from "vue";
+import { shallowRef as shallowRef10, unref as unref12 } from "vue";
 function useSolanaTransaction(options) {
   const guard = useActionGuard();
-  const isSigning = shallowRef9(false);
-  const isSending = shallowRef9(false);
+  const isSigning = shallowRef10(false);
+  const isSending = shallowRef10(false);
   let signing = 0;
   let sending = 0;
   const signTransaction = (transaction) => {
-    const invoke = unref11(options.signTransaction);
+    const invoke = unref12(options.signTransaction);
     signing++;
     isSigning.value = true;
     return guard.run(() => invoke(transaction), "Signing failed").finally(() => {
@@ -1033,7 +1098,7 @@ function useSolanaTransaction(options) {
     });
   };
   const sendTransaction = (transaction) => {
-    const invoke = unref11(options.sendTransaction);
+    const invoke = unref12(options.sendTransaction);
     sending++;
     isSending.value = true;
     return guard.run(() => invoke(transaction), "Send failed").finally(() => {
@@ -1041,7 +1106,7 @@ function useSolanaTransaction(options) {
       isSending.value = sending > 0;
     });
   };
-  const getStatus = (signature) => unref11(options.getStatus)(signature);
+  const getStatus = (signature) => unref12(options.getStatus)(signature);
   return {
     signTransaction,
     sendTransaction,
@@ -1054,12 +1119,12 @@ function useSolanaTransaction(options) {
 }
 
 // src/useSignInWithX.ts
-import { shallowRef as shallowRef10, unref as unref12 } from "vue";
+import { shallowRef as shallowRef11, unref as unref13 } from "vue";
 function useSignInWithX(action) {
   const guard = useActionGuard();
-  const result = shallowRef10(null);
+  const result = shallowRef11(null);
   const signIn = (options) => {
-    const invoke = unref12(action);
+    const invoke = unref13(action);
     return guard.run(async (commit) => {
       const next = await invoke(options);
       commit(() => {
@@ -1088,17 +1153,17 @@ function useSignInWithEthereum(action) {
 }
 
 // src/useExecuteCalls.ts
-import { computed as computed10, toValue as toValue11, unref as unref13 } from "vue";
+import { computed as computed10, toValue as toValue11, unref as unref14 } from "vue";
 function useExecuteCalls(options) {
   const guard = useActionGuard();
-  const preview = (callCount, atomicity) => unref13(options.preview)(callCount, atomicity);
+  const preview = (callCount, atomicity) => unref14(options.preview)(callCount, atomicity);
   const execute = (calls, atomicity) => {
-    const invoke = unref13(options.execute);
+    const invoke = unref14(options.execute);
     return guard.run(() => invoke(calls, atomicity), "Execution failed");
   };
   const reset = () => {
     guard.reset();
-    unref13(options.reset)();
+    unref14(options.reset)();
   };
   return {
     preview,
@@ -1119,24 +1184,24 @@ import {
 } from "@naculus/connect-appkit-core";
 import {
   computed as computed12,
-  onScopeDispose as onScopeDispose7,
-  shallowRef as shallowRef12,
+  onScopeDispose as onScopeDispose8,
+  shallowRef as shallowRef13,
   toValue as toValue13,
-  unref as unref14,
-  watch as watch6
+  unref as unref15,
+  watch as watch7
 } from "vue";
 
 // src/useSessionKeys.ts
 import { getSharedSessionKeyManager } from "@naculus/connect-appkit-core";
-import { computed as computed11, onScopeDispose as onScopeDispose6, shallowRef as shallowRef11, toValue as toValue12, watch as watch5 } from "vue";
+import { computed as computed11, onScopeDispose as onScopeDispose7, shallowRef as shallowRef12, toValue as toValue12, watch as watch6 } from "vue";
 function resolveManager(config, options) {
   return options.manager ?? getSharedSessionKeyManager(config);
 }
 function useSessionKeys(connected, config, options = {}) {
   const manager = resolveManager(config, options);
-  const sessions = shallowRef11([]);
-  const loading = shallowRef11(false);
-  const error = shallowRef11(null);
+  const sessions = shallowRef12([]);
+  const loading = shallowRef12(false);
+  const error = shallowRef12(null);
   let generation = 0;
   let disposed = false;
   const refresh = async () => {
@@ -1158,14 +1223,14 @@ function useSessionKeys(connected, config, options = {}) {
       if (!disposed && own === generation) loading.value = false;
     }
   };
-  watch5(
+  watch6(
     () => toValue12(connected),
     () => {
       void refresh();
     },
     { immediate: true }
   );
-  onScopeDispose6(() => {
+  onScopeDispose7(() => {
     disposed = true;
     generation++;
   });
@@ -1186,7 +1251,7 @@ function useSessionKeys(connected, config, options = {}) {
 function useCreateSessionKey(config, options = {}) {
   const manager = resolveManager(config, options);
   const guard = useActionGuard();
-  const lastCreated = shallowRef11(null);
+  const lastCreated = shallowRef12(null);
   return {
     createSessionKey: (scope, signerAddress) => guard.run(async () => {
       const info = await manager.createSessionKey(scope, signerAddress);
@@ -1237,9 +1302,9 @@ function useDelegationPolicy(options) {
     manager
   });
   const guard = useActionGuard();
-  const verifiedIds = shallowRef12(/* @__PURE__ */ new Set());
-  const isVerifying = shallowRef12(false);
-  const verifyError = shallowRef12(null);
+  const verifiedIds = shallowRef13(/* @__PURE__ */ new Set());
+  const isVerifying = shallowRef13(false);
+  const verifyError = shallowRef13(null);
   let verifyGeneration = 0;
   let disposed = false;
   const origin = options.origin ?? (typeof window !== "undefined" ? window.location.origin : "unknown");
@@ -1247,12 +1312,12 @@ function useDelegationPolicy(options) {
     manager,
     origin,
     signer: () => bareEvmAddress2(toValue13(options.account)),
-    signMessage: (message) => unref14(options.signMessage)(message),
-    verifySignature: (input) => unref14(options.verifySignature)(input),
-    previewExecution: (callCount, atomicity) => unref14(options.previewExecution)(callCount, atomicity),
+    signMessage: (message) => unref15(options.signMessage)(message),
+    verifySignature: (input) => unref15(options.verifySignature)(input),
+    previewExecution: (callCount, atomicity) => unref15(options.previewExecution)(callCount, atomicity),
     sponsorship: options.sponsorship,
     adapter: options.adapter,
-    signTypedData: options.signTypedData ? (typedData) => unref14(
+    signTypedData: options.signTypedData ? (typedData) => unref15(
       options.signTypedData
     )(typedData) : void 0,
     chainId: () => toValue13(options.chainId) ?? null,
@@ -1261,7 +1326,7 @@ function useDelegationPolicy(options) {
     storageAvailable: () => sessionKeys.storageAvailable,
     refresh: sessionKeys.refresh
   });
-  watch6(
+  watch7(
     () => sessionKeys.sessions.value,
     (sessions) => {
       const own = ++verifyGeneration;
@@ -1291,7 +1356,7 @@ function useDelegationPolicy(options) {
     },
     { immediate: true }
   );
-  onScopeDispose7(() => {
+  onScopeDispose8(() => {
     disposed = true;
     verifyGeneration++;
   });
@@ -1334,18 +1399,18 @@ import {
 import { WalletError as WalletError5 } from "@naculus/connect-core";
 import {
   computed as computed13,
-  onScopeDispose as onScopeDispose8,
-  shallowRef as shallowRef13,
+  onScopeDispose as onScopeDispose9,
+  shallowRef as shallowRef14,
   toValue as toValue14,
-  unref as unref15,
-  watch as watch7
+  unref as unref16,
+  watch as watch8
 } from "vue";
 function useSmartAccount(options) {
-  const address = shallowRef13(null);
-  const isDeployed = shallowRef13(false);
-  const accountInfo = shallowRef13(null);
+  const address = shallowRef14(null);
+  const isDeployed = shallowRef14(false);
+  const accountInfo = shallowRef14(null);
   const guard = useActionGuard();
-  const managerRef = shallowRef13(null);
+  const managerRef = shallowRef14(null);
   let generation = 0;
   let inFlight = false;
   let disposed = false;
@@ -1355,7 +1420,7 @@ function useSmartAccount(options) {
       toValue14(options.connectedChainId)
     )
   );
-  watch7(
+  watch8(
     [
       () => toValue14(options.manager),
       () => toValue14(options.rpcUrl),
@@ -1435,7 +1500,7 @@ function useSmartAccount(options) {
     return info;
   }, "Failed to create smart account");
   const deployWallet = () => operate(async (manager, cfg, commit) => {
-    const send = unref15(options.sendTransaction);
+    const send = unref16(options.sendTransaction);
     if (!send) {
       throw new WalletError5(
         "wallet_unavailable",
@@ -1465,7 +1530,7 @@ function useSmartAccount(options) {
     });
     return addr;
   }, "Failed to get smart account address");
-  onScopeDispose8(() => {
+  onScopeDispose9(() => {
     disposed = true;
     generation++;
   });
@@ -1489,13 +1554,13 @@ import {
   resolveUserOpChain
 } from "@naculus/connect-appkit-core";
 import { WalletError as WalletError6 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose9, shallowRef as shallowRef14, toValue as toValue15, unref as unref16 } from "vue";
+import { onScopeDispose as onScopeDispose10, shallowRef as shallowRef15, toValue as toValue15, unref as unref17 } from "vue";
 function useSendUserOperation(options) {
-  const userOpHash = shallowRef14(null);
-  const receipt = shallowRef14(null);
-  const isPending = shallowRef14(false);
-  const isEstimating = shallowRef14(false);
-  const error = shallowRef14(null);
+  const userOpHash = shallowRef15(null);
+  const receipt = shallowRef15(null);
+  const isPending = shallowRef15(false);
+  const isEstimating = shallowRef15(false);
+  const error = shallowRef15(null);
   let requestId = 0;
   let inFlight = false;
   let disposed = false;
@@ -1529,7 +1594,7 @@ function useSendUserOperation(options) {
     } catch (chainError) {
       return fail(chainError);
     }
-    const signer = unref16(options.signer);
+    const signer = unref17(options.signer);
     const own = ++requestId;
     inFlight = true;
     isPending.value = true;
@@ -1580,7 +1645,7 @@ function useSendUserOperation(options) {
     isEstimating.value = false;
     error.value = null;
   };
-  onScopeDispose9(() => {
+  onScopeDispose10(() => {
     disposed = true;
     requestId++;
   });
@@ -1600,15 +1665,15 @@ import {
   fetchUserOperationReceipt,
   InvalidUserOperationReceiptError
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose10, shallowRef as shallowRef15, toValue as toValue16 } from "vue";
+import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef16, toValue as toValue16 } from "vue";
 function useUserOpStatus(options) {
-  const status = shallowRef15("idle");
-  const receipt = shallowRef15(null);
-  const userOpHash = shallowRef15(null);
-  const error = shallowRef15(null);
-  const isPolling = shallowRef15(false);
-  const elapsedMs = shallowRef15(0);
-  const attempts = shallowRef15(0);
+  const status = shallowRef16("idle");
+  const receipt = shallowRef16(null);
+  const userOpHash = shallowRef16(null);
+  const error = shallowRef16(null);
+  const isPolling = shallowRef16(false);
+  const elapsedMs = shallowRef16(0);
+  const attempts = shallowRef16(0);
   const pollInterval = options.pollInterval ?? 2e3;
   const maxRetries = options.maxRetries ?? 30;
   let generation = 0;
@@ -1714,7 +1779,7 @@ function useUserOpStatus(options) {
     attempts.value = 0;
     elapsedMs.value = 0;
   };
-  onScopeDispose10(stop);
+  onScopeDispose11(stop);
   return {
     status,
     receipt,
@@ -1730,17 +1795,17 @@ function useUserOpStatus(options) {
 }
 
 // src/useSendCalls.ts
-import { computed as computed14, onScopeDispose as onScopeDispose11, shallowRef as shallowRef16, toValue as toValue17, unref as unref17 } from "vue";
+import { computed as computed14, onScopeDispose as onScopeDispose12, shallowRef as shallowRef17, toValue as toValue17, unref as unref18 } from "vue";
 function useSendCalls(options) {
-  const status = shallowRef16("idle");
-  const error = shallowRef16(null);
-  const batchHash = shallowRef16(null);
-  const callsStatus = shallowRef16(null);
+  const status = shallowRef17("idle");
+  const error = shallowRef17(null);
+  const batchHash = shallowRef17(null);
+  const callsStatus = shallowRef17(null);
   let sendGeneration = 0;
   let statusGeneration = 0;
   let disposed = false;
   const sendCalls = async (calls, input) => {
-    const invoke = unref17(options.sendCalls);
+    const invoke = unref18(options.sendCalls);
     const own = ++sendGeneration;
     status.value = "awaiting_approval";
     error.value = null;
@@ -1762,13 +1827,13 @@ function useSendCalls(options) {
     }
   };
   const getCallsStatus = async (hash) => {
-    const invoke = unref17(options.getCallsStatus);
+    const invoke = unref18(options.getCallsStatus);
     const own = ++statusGeneration;
     const result = await invoke(hash);
     if (!disposed && own === statusGeneration) callsStatus.value = result;
     return result;
   };
-  const showCallsStatus = (hash) => unref17(options.showCallsStatus)(hash);
+  const showCallsStatus = (hash) => unref18(options.showCallsStatus)(hash);
   const reset = () => {
     sendGeneration++;
     statusGeneration++;
@@ -1777,7 +1842,7 @@ function useSendCalls(options) {
     batchHash.value = null;
     callsStatus.value = null;
   };
-  onScopeDispose11(() => {
+  onScopeDispose12(() => {
     disposed = true;
     sendGeneration++;
     statusGeneration++;
@@ -1797,7 +1862,7 @@ function useSendCalls(options) {
 }
 
 // src/useEmbeddedWallet.ts
-import { computed as computed15, toValue as toValue18, unref as unref18 } from "vue";
+import { computed as computed15, toValue as toValue18, unref as unref19 } from "vue";
 function useEmbeddedWallet(options) {
   const guard = useActionGuard();
   const run = (action) => guard.run(action, "Embedded wallet action failed");
@@ -1811,17 +1876,17 @@ function useEmbeddedWallet(options) {
     backupPending: computed15(() => toValue18(options.backupPending)),
     storageSecurityLevel: computed15(() => toValue18(options.storageSecurityLevel)),
     securityReport: computed15(() => toValue18(options.securityReport)),
-    connectEmbedded: () => run(() => unref18(options.connectEmbedded)()),
-    restoreWallet: () => run(() => unref18(options.restoreWallet)()),
-    generateWallet: () => run(() => unref18(options.generateWallet)()),
-    importFromMnemonic: (value) => run(() => unref18(options.importFromMnemonic)(value)),
-    importFromPrivateKey: (value) => run(() => unref18(options.importFromPrivateKey)(value)),
-    wipe: () => run(() => unref18(options.wipe)()),
-    setActiveNamespace: (value) => unref18(options.setActiveNamespace)(value),
-    backfillAccounts: () => run(() => unref18(options.backfillAccounts)()),
-    getSeedPhrase: () => unref18(options.getSeedPhrase)(),
-    getPrivateKey: () => unref18(options.getPrivateKey)(),
-    confirmBackup: () => unref18(options.confirmBackup)(),
+    connectEmbedded: () => run(() => unref19(options.connectEmbedded)()),
+    restoreWallet: () => run(() => unref19(options.restoreWallet)()),
+    generateWallet: () => run(() => unref19(options.generateWallet)()),
+    importFromMnemonic: (value) => run(() => unref19(options.importFromMnemonic)(value)),
+    importFromPrivateKey: (value) => run(() => unref19(options.importFromPrivateKey)(value)),
+    wipe: () => run(() => unref19(options.wipe)()),
+    setActiveNamespace: (value) => unref19(options.setActiveNamespace)(value),
+    backfillAccounts: () => run(() => unref19(options.backfillAccounts)()),
+    getSeedPhrase: () => unref19(options.getSeedPhrase)(),
+    getPrivateKey: () => unref19(options.getPrivateKey)(),
+    confirmBackup: () => unref19(options.confirmBackup)(),
     isBusy: guard.busy,
     error: guard.error,
     clearError: guard.clearError
@@ -1840,7 +1905,7 @@ function useSIWxLogin(action) {
 }
 
 // src/useSIWxSession.ts
-import { computed as computed16, toValue as toValue19, unref as unref19 } from "vue";
+import { computed as computed16, toValue as toValue19, unref as unref20 } from "vue";
 function useSIWxSession(options) {
   const guard = useActionGuard();
   return {
@@ -1852,25 +1917,25 @@ function useSIWxSession(options) {
     isSigningIn: guard.busy,
     isExpired: computed16(() => toValue19(options.isExpired)),
     timeUntilExpiry: computed16(() => toValue19(options.timeUntilExpiry)),
-    signIn: (input) => guard.run(() => unref19(options.signIn)(input), "SIWX sign-in failed"),
+    signIn: (input) => guard.run(() => unref20(options.signIn)(input), "SIWX sign-in failed"),
     signOut: async () => {
-      await unref19(options.signOut)();
+      await unref20(options.signOut)();
       guard.clearError();
     },
-    refresh: () => guard.run(() => unref19(options.refresh)(), "Session refresh failed"),
+    refresh: () => guard.run(() => unref20(options.refresh)(), "Session refresh failed"),
     error: guard.error,
     clearError: guard.clearError
   };
 }
 
 // src/useSiwxAuthSession.ts
-import { computed as computed17, toValue as toValue20, unref as unref20 } from "vue";
+import { computed as computed17, toValue as toValue20, unref as unref21 } from "vue";
 function useSiwxAuthSession(options) {
   const guard = useActionGuard();
-  const signIn = (input) => guard.run(() => unref20(options.signIn)(input), "SIWX sign-in failed");
+  const signIn = (input) => guard.run(() => unref21(options.signIn)(input), "SIWX sign-in failed");
   const signOut = async () => {
     guard.reset();
-    await unref20(options.signOut)();
+    await unref21(options.signOut)();
     guard.clearError();
   };
   const siwxResult = computed17(() => toValue20(options.result));
@@ -1889,11 +1954,11 @@ function useSiwxAuthSession(options) {
 // src/useBalance.ts
 import { bareEvmAddress as bareEvmAddress5 } from "@naculus/connect-appkit-core";
 import { formatUnits as formatUnits2 } from "@naculus/connect-core";
-import { computed as computed18, onScopeDispose as onScopeDispose12, shallowRef as shallowRef17, toValue as toValue21, watch as watch8 } from "vue";
+import { computed as computed18, onScopeDispose as onScopeDispose13, shallowRef as shallowRef18, toValue as toValue21, watch as watch9 } from "vue";
 function useBalance(account, client, options = {}) {
   const guard = useActionGuard();
-  const balance = shallowRef17(null);
-  const isFetching = shallowRef17(false);
+  const balance = shallowRef18(null);
+  const isFetching = shallowRef18(false);
   let timer = null;
   const refetch = async () => {
     const reader = toValue21(client);
@@ -1933,7 +1998,7 @@ function useBalance(account, client, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  watch8(
+  watch9(
     [
       () => toValue21(account),
       () => toValue21(client),
@@ -1946,7 +2011,7 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose12(stopTimer);
+  onScopeDispose13(stopTimer);
   return {
     balance,
     formatted: computed18(
@@ -1963,11 +2028,11 @@ function useBalance(account, client, options = {}) {
 import {
   isQuotableInput
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose13, shallowRef as shallowRef18, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
+import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef19, toValue as toValue22, unref as unref22, watch as watch10 } from "vue";
 function useRouteQuote(input, getQuotes, options = {}) {
   const guard = useActionGuard();
-  const quotes = shallowRef18([]);
-  const loading = shallowRef18(false);
+  const quotes = shallowRef19([]);
+  const loading = shallowRef19(false);
   let timer = null;
   const clearTimer = () => {
     if (timer) clearTimeout(timer);
@@ -1980,7 +2045,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
       quotes.value = [];
       return null;
     }
-    const fn = unref21(getQuotes);
+    const fn = unref22(getQuotes);
     if (!fn) {
       guard.invalidate();
       loading.value = false;
@@ -2024,14 +2089,14 @@ function useRouteQuote(input, getQuotes, options = {}) {
     ).catch(() => {
     });
   };
-  watch9(
+  watch10(
     [
       () => toValue22(input).fromChain,
       () => toValue22(input).toChain,
       () => toValue22(input).fromToken,
       () => toValue22(input).toToken,
       () => toValue22(input).amount,
-      () => unref21(getQuotes)
+      () => unref22(getQuotes)
     ],
     () => {
       clearTimer();
@@ -2044,7 +2109,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose13(clearTimer);
+  onScopeDispose14(clearTimer);
   return {
     quotes,
     loading,
@@ -2063,14 +2128,14 @@ function useRouteQuote(input, getQuotes, options = {}) {
 import {
   compareCostsKey
 } from "@naculus/connect-appkit-core";
-import { shallowRef as shallowRef19, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
+import { shallowRef as shallowRef20, toValue as toValue23, unref as unref23, watch as watch11 } from "vue";
 function useCompareCosts(input, compareCosts) {
   const guard = useActionGuard();
-  const comparisons = shallowRef19([]);
-  const loading = shallowRef19(false);
+  const comparisons = shallowRef20([]);
+  const loading = shallowRef20(false);
   const fetchComparisons = async () => {
     const { operation, chains, options } = toValue23(input);
-    const fn = unref22(compareCosts);
+    const fn = unref23(compareCosts);
     if (!chains || chains.length === 0) {
       guard.invalidate();
       loading.value = false;
@@ -2107,8 +2172,8 @@ function useCompareCosts(input, compareCosts) {
     ).catch(() => {
     });
   };
-  watch10(
-    [() => compareCostsKey(toValue23(input)), () => unref22(compareCosts)],
+  watch11(
+    [() => compareCostsKey(toValue23(input)), () => unref23(compareCosts)],
     () => {
       void fetchComparisons();
     },
@@ -2127,15 +2192,15 @@ import {
   toExecuteRouteError,
   validateRouteRecipient
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef20, unref as unref23 } from "vue";
+import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef21, unref as unref24 } from "vue";
 function useExecuteRoute(executeRoute) {
-  const executing = shallowRef20(false);
-  const result = shallowRef20(null);
-  const error = shallowRef20(null);
+  const executing = shallowRef21(false);
+  const result = shallowRef21(null);
+  const error = shallowRef21(null);
   let inFlight = false;
   let disposed = false;
   const execute = async (quote, recipient, options) => {
-    const fn = unref23(executeRoute);
+    const fn = unref24(executeRoute);
     if (!fn) {
       error.value = {
         code: "no_executor",
@@ -2173,7 +2238,7 @@ function useExecuteRoute(executeRoute) {
       if (!disposed) executing.value = false;
     }
   };
-  onScopeDispose14(() => {
+  onScopeDispose15(() => {
     disposed = true;
   });
   return {
@@ -2194,15 +2259,15 @@ import { eip155ChainIdToNumber } from "@naculus/connect-appkit-core";
 import {
   TokenListManager
 } from "@naculus/connect-core";
-import { shallowRef as shallowRef21, toValue as toValue24, watch as watch11 } from "vue";
+import { shallowRef as shallowRef22, toValue as toValue24, watch as watch12 } from "vue";
 function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
   const manager = options.manager ?? new TokenListManager(config);
   const guard = useActionGuard();
-  const tokens = shallowRef21([]);
-  const isLoading = shallowRef21(options.autoLoad !== false);
-  const isLoaded = shallowRef21(false);
+  const tokens = shallowRef22([]);
+  const isLoading = shallowRef22(options.autoLoad !== false);
+  const isLoaded = shallowRef22(false);
   const select = () => {
     const id = toValue24(chainId);
     const numeric = id ? eip155ChainIdToNumber(id) : void 0;
@@ -2230,7 +2295,7 @@ function useTokenList(chainId, options = {}) {
     ).catch(() => {
     });
   };
-  watch11(
+  watch12(
     () => toValue24(chainId),
     () => {
       if (options.autoLoad !== false) void run(() => manager.load());
@@ -2251,7 +2316,7 @@ import { eip155ChainIdToNumber as eip155ChainIdToNumber2 } from "@naculus/connec
 import {
   TokenListManager as TokenListManager2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef22, toValue as toValue25, watch as watch12 } from "vue";
+import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef23, toValue as toValue25, watch as watch13 } from "vue";
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
@@ -2264,14 +2329,14 @@ function getSharedManager() {
   return sharedManager;
 }
 function useTokenSearch(query, chainId, options = {}) {
-  const results = shallowRef22(EMPTY);
-  const isSearching = shallowRef22(false);
+  const results = shallowRef23(EMPTY);
+  const isSearching = shallowRef23(false);
   let timer = null;
   const clear = () => {
     if (timer) clearTimeout(timer);
     timer = null;
   };
-  watch12(
+  watch13(
     [() => (toValue25(query) ?? "").trim(), () => toValue25(chainId)],
     ([q, id]) => {
       clear();
@@ -2294,7 +2359,7 @@ function useTokenSearch(query, chainId, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose15(clear);
+  onScopeDispose16(clear);
   return { results, isSearching };
 }
 
@@ -2312,14 +2377,14 @@ function useValidateDestination(address) {
 // src/useTokenBalance.ts
 import { bareEvmAddress as bareEvmAddress6 } from "@naculus/connect-appkit-core";
 import { ERC20_MIN_ABI as ERC20_MIN_ABI3, formatUnits as formatUnits3 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef23, toValue as toValue27, watch as watch13 } from "vue";
+import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef24, toValue as toValue27, watch as watch14 } from "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 = shallowRef23([]);
-  const isFetching = shallowRef23(false);
+  const tokenBalances = shallowRef24([]);
+  const isFetching = shallowRef24(false);
   let timer = null;
   const refetch = async () => {
     const reader = toValue27(client);
@@ -2379,7 +2444,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  watch13(
+  watch14(
     [
       () => toValue27(account),
       () => toValue27(client),
@@ -2393,7 +2458,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose16(stopTimer);
+  onScopeDispose17(stopTimer);
   return {
     tokenBalances,
     isFetching,
@@ -2413,11 +2478,11 @@ import {
   REVOKE_DELEGATE,
   WalletError as WalletError7
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef24, toValue as toValue28, watch as watch14 } from "vue";
+import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef25, toValue as toValue28, watch as watch15 } from "vue";
 function useDelegate(options) {
-  const result = shallowRef24(null);
-  const isPending = shallowRef24(false);
-  const error = shallowRef24(null);
+  const result = shallowRef25(null);
+  const isPending = shallowRef25(false);
+  const error = shallowRef25(null);
   let requestId = 0;
   let inFlight = false;
   let disposed = false;
@@ -2479,7 +2544,7 @@ function useDelegate(options) {
     isPending.value = false;
     error.value = null;
   };
-  watch14(
+  watch15(
     [
       () => toValue28(options.session),
       () => toValue28(options.account),
@@ -2488,7 +2553,7 @@ function useDelegate(options) {
     reset,
     { flush: "sync" }
   );
-  onScopeDispose17(() => {
+  onScopeDispose18(() => {
     disposed = true;
     requestId++;
   });
@@ -2508,11 +2573,11 @@ import {
   readDelegation,
   UNKNOWN_DELEGATION
 } from "@naculus/connect-core";
-import { computed as computed20, shallowRef as shallowRef25, toValue as toValue29, watch as watch15 } from "vue";
+import { computed as computed20, shallowRef as shallowRef26, toValue as toValue29, watch as watch16 } from "vue";
 function useDelegation(account, client, chainId) {
   const guard = useActionGuard();
-  const status = shallowRef25(UNKNOWN_DELEGATION);
-  const isFetching = shallowRef25(false);
+  const status = shallowRef26(UNKNOWN_DELEGATION);
+  const isFetching = shallowRef26(false);
   const refetch = async () => {
     const reader = toValue29(client);
     const address = bareEvmAddress8(toValue29(account));
@@ -2547,7 +2612,7 @@ function useDelegation(account, client, chainId) {
     ).catch(() => {
     });
   };
-  watch15(
+  watch16(
     [() => toValue29(account), () => toValue29(client), () => toValue29(chainId)],
     () => {
       void refetch();
@@ -2565,23 +2630,65 @@ function useDelegation(account, client, chainId) {
 
 // src/usePaymentFetch.ts
 import {
+  applySettlementVerification,
+  DEFAULT_VERIFY_RETRY,
   describePayment
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef26, unref as unref24 } from "vue";
-function usePaymentFetch(pay) {
+import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef27, unref as unref25 } from "vue";
+function usePaymentFetch(pay, options = {}) {
   const guard = useActionGuard();
-  const lastPayment = shallowRef26(null);
+  const lastPayment = shallowRef27(null);
   let epoch = 0;
-  onScopeDispose18(() => {
+  let verification = 0;
+  onScopeDispose19(() => {
     epoch++;
+    verification++;
   });
   const payFetch = (input, init) => {
-    const invoke = unref24(pay);
+    const invoke = unref25(pay);
     const own = epoch;
     return guard.run(async () => {
       const result = await invoke(input, init);
-      const payment = describePayment(input, result);
-      if (payment && own === epoch) lastPayment.value = payment;
+      let payment = describePayment(input, result);
+      if (payment && own === epoch) {
+        const verify = options.verify;
+        if (!verify) {
+          lastPayment.value = payment;
+        } else {
+          payment = applySettlementVerification(payment, { status: "pending" });
+          lastPayment.value = payment;
+          const verificationOwn = ++verification;
+          const retry = options.verifyRetry ?? 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 = applySettlementVerification(
+                  current,
+                  outcome
+                );
+            }
+          });
+        }
+      }
       return result;
     }, "Paid request failed");
   };
@@ -2592,24 +2699,156 @@ function usePaymentFetch(pay) {
     error: guard.error,
     reset: () => {
       epoch++;
+      verification++;
       guard.reset();
       lastPayment.value = null;
     }
   };
 }
 
+// src/useMppSession.ts
+import {
+  readCurrentMppSessionChannel,
+  readMppRecoveryChannelId,
+  readMppSessionReceipt
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose20, shallowRef as shallowRef28, unref as unref26, watch as watch17 } from "vue";
+function useMppSession(session) {
+  const current = () => unref26(session);
+  const pending = shallowRef28(current().meter.pending);
+  const channel = shallowRef28(
+    readCurrentMppSessionChannel(current())
+  );
+  const lastReceipt = shallowRef28(null);
+  const recoveryChannelId = shallowRef28(null);
+  const isPending = shallowRef28(false);
+  const error = shallowRef28(null);
+  let active = 0;
+  let generation = 0;
+  let epoch = 0;
+  let disposed = false;
+  watch17(
+    () => unref26(session),
+    (value) => {
+      generation++;
+      epoch++;
+      active = 0;
+      isPending.value = false;
+      pending.value = value.meter.pending;
+      channel.value = readCurrentMppSessionChannel(value);
+      lastReceipt.value = null;
+      recoveryChannelId.value = null;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  onScopeDispose20(() => {
+    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 = 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 = readCurrentMppSessionChannel(invokedSession);
+        channel.value = currentChannel;
+        pending.value = invokedSession.meter.pending;
+        const recovery = 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 = readMppSessionReceipt(result.receipt);
+      if (receipt) lastReceipt.value = receipt;
+    }
+  );
+  const close = () => run(
+    (value) => value.close(),
+    (result) => {
+      const receipt = 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 = 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 = readCurrentMppSessionChannel(current());
+      lastReceipt.value = null;
+      recoveryChannelId.value = null;
+      error.value = null;
+    }
+  };
+}
+
 // src/useSolanaSessionKey.ts
 import {
   createSolanaSessionKeyFlow
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef27, unref as unref25, watch as watch16 } from "vue";
+import { onScopeDispose as onScopeDispose21, shallowRef as shallowRef29, unref as unref27, watch as watch18 } from "vue";
 function useSolanaSessionKey(deps) {
   const guard = useActionGuard();
-  const keys = shallowRef27([]);
+  const keys = shallowRef29([]);
   let flow = null;
   let generation = 0;
   let disposed = false;
-  onScopeDispose19(() => {
+  onScopeDispose21(() => {
     disposed = true;
   });
   const refresh = async () => {
@@ -2617,8 +2856,8 @@ function useSolanaSessionKey(deps) {
     const next = flow ? await flow.list() : [];
     if (!disposed && own === generation) keys.value = next;
   };
-  watch16(
-    () => unref25(deps),
+  watch18(
+    () => unref27(deps),
     (next) => {
       flow = next ? createSolanaSessionKeyFlow(next) : null;
       guard.invalidate();
@@ -2652,11 +2891,11 @@ function useSolanaSessionKey(deps) {
 
 // src/name-lookup.ts
 import { getResolver } from "@naculus/connect-appkit-core";
-import { computed as computed21, shallowRef as shallowRef28, toValue as toValue30, watch as watch17 } from "vue";
+import { computed as computed21, shallowRef as shallowRef30, toValue as toValue30, watch as watch19 } from "vue";
 function useNameLookup(options) {
   const guard = useActionGuard();
-  const data = shallowRef28(null);
-  const loading = shallowRef28(false);
+  const data = shallowRef30(null);
+  const loading = shallowRef30(false);
   const run = () => {
     const input = toValue30(options.input).trim();
     const skip = toValue30(options.skip) ?? false;
@@ -2696,7 +2935,7 @@ function useNameLookup(options) {
     ).catch(() => {
     });
   };
-  watch17(
+  watch19(
     () => [
       toValue30(options.input),
       toValue30(options.skip),
@@ -2784,13 +3023,13 @@ function useChain(chains, chainId) {
 }
 
 // src/usePassphraseGate.ts
-import { onScopeDispose as onScopeDispose20, readonly, shallowRef as shallowRef29 } from "vue";
+import { onScopeDispose as onScopeDispose22, readonly, shallowRef as shallowRef31 } from "vue";
 function usePassphraseGate(gate) {
-  const request = shallowRef29(gate.getSnapshot());
+  const request = shallowRef31(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  onScopeDispose20(unsubscribe);
+  onScopeDispose22(unsubscribe);
   return {
     request: readonly(request),
     submit: (passphrase) => gate.submit(passphrase),
@@ -2801,10 +3040,10 @@ function usePassphraseGate(gate) {
 
 // src/useSolanaBalance.ts
 import { getSolanaBalance } from "@naculus/connect-core";
-import { ref, shallowRef as shallowRef30, toValue as toValue33, watchEffect } from "vue";
+import { ref, shallowRef as shallowRef32, toValue as toValue33, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
   const guard = useActionGuard();
-  const balance = shallowRef30(null);
+  const balance = shallowRef32(null);
   const isFetching = ref(false);
   const refetch = async () => {
     const addr = toValue33(address);
@@ -2849,12 +3088,12 @@ function useSolanaBalance(address, rpcUrl) {
 }
 
 // src/useLastTx.ts
-import { shallowRef as shallowRef31, toValue as toValue34, watch as watch18 } from "vue";
+import { shallowRef as shallowRef33, toValue as toValue34, watch as watch20 } from "vue";
 function useLastTx(monitor) {
-  const lastTx = shallowRef31(null);
-  const lastConfirmedTx = shallowRef31(null);
-  const lastFailedTx = shallowRef31(null);
-  watch18(
+  const lastTx = shallowRef33(null);
+  const lastConfirmedTx = shallowRef33(null);
+  const lastFailedTx = shallowRef33(null);
+  watch20(
     () => toValue34(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
@@ -2893,11 +3132,11 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-import { computed as computed24, shallowRef as shallowRef32, toValue as toValue35, watch as watch19 } from "vue";
+import { computed as computed24, shallowRef as shallowRef34, toValue as toValue35, watch as watch21 } from "vue";
 function useTxHistory(address, chainId, monitor) {
   const guard = useActionGuard();
-  const entries = shallowRef32([]);
-  const isLoading = shallowRef32(false);
+  const entries = shallowRef34([]);
+  const isLoading = shallowRef34(false);
   const refresh = async () => {
     const activeMonitor = toValue35(monitor);
     if (!activeMonitor) {
@@ -2927,7 +3166,7 @@ function useTxHistory(address, chainId, monitor) {
     ).catch(() => {
     });
   };
-  watch19(
+  watch21(
     [() => toValue35(monitor), () => toValue35(address), () => toValue35(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
@@ -2957,11 +3196,11 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-import { computed as computed25, shallowRef as shallowRef33, toValue as toValue36, watch as watch20 } from "vue";
+import { computed as computed25, shallowRef as shallowRef35, toValue as toValue36, watch as watch22 } from "vue";
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = shallowRef33(null);
-  const isLoading = shallowRef33(false);
-  const isWatching = shallowRef33(false);
+  const entry = shallowRef35(null);
+  const isLoading = shallowRef35(false);
+  const isWatching = shallowRef35(false);
   const guard = useActionGuard();
   const error = guard.error;
   let generation = 0;
@@ -3018,7 +3257,7 @@ function useTxMonitor(hash, chainId, monitor) {
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  watch20(
+  watch22(
     [() => toValue36(monitor), () => toValue36(hash), () => toValue36(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
@@ -3076,13 +3315,13 @@ import {
   normalizeCapabilities,
   selectChainCapabilities
 } from "@naculus/connect-appkit-core";
-import { computed as computed26, shallowRef as shallowRef34, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
+import { computed as computed26, shallowRef as shallowRef36, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
   const guard = useActionGuard();
-  const capabilities = shallowRef34(
+  const capabilities = shallowRef36(
     null
   );
-  const isFetching = shallowRef34(false);
+  const isFetching = shallowRef36(false);
   const refetch = async () => {
     const activeClient = toValue37(client);
     const activeSession = toValue37(session);
@@ -3184,6 +3423,7 @@ export {
   AppkitTooltip,
   useAccount,
   useAccounts,
+  useAuthorizations,
   useBalance,
   useCapabilities,
   useChain,
@@ -3202,6 +3442,7 @@ export {
   useExecuteRoute,
   useLastTx,
   useLookupAddress,
+  useMppSession,
   useNotification,
   usePassphraseGate,
   usePaymentFetch,