@naculus/connect-appkit-vue 0.3.0 → 0.5.0

package/dist/index.js

@@ -292,99 +292,145 @@ import { resolveSimulationEndpoint } from "@naculus/connect-appkit-core";
 import {
   SimulationManager
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose2, shallowRef as shallowRef2, unref as unref2 } from "vue";
-function useSimulateTransfer(options = {}) {
-  const result = shallowRef2(null);
-  const loading = shallowRef2(false);
+import { shallowRef as shallowRef3, unref as unref2 } from "vue";
+
+// src/internal/action-guard.ts
+import { onScopeDispose as onScopeDispose2, shallowRef as shallowRef2 } from "vue";
+function useActionGuard() {
+  const busy = shallowRef2(false);
   const error = shallowRef2(null);
-  let manager;
+  let active = 0;
   let generation = 0;
   let disposed = false;
-  const simulate = async (tokenAddress, from, to, amount, callOptions) => {
+  const run = async (action, fallbackMessage, normalizeError, options = {}) => {
     const own = ++generation;
-    loading.value = true;
-    error.value = null;
+    const commit = (write) => {
+      if (!disposed && own === generation) write();
+    };
+    active++;
+    busy.value = true;
+    if (!options.keepError) error.value = null;
     try {
-      const fallbackRpcUrl = unref2(options.rpcUrl);
-      const endpoint = resolveSimulationEndpoint(
-        callOptions?.chainId,
-        unref2(options.chainId),
-        callOptions?.rpcUrl,
-        fallbackRpcUrl
-      );
-      manager ??= new SimulationManager({
-        enabled: true,
-        rpcUrl: fallbackRpcUrl,
-        autoSimulate: false
-      });
-      const value = await manager.simulateERC20Transfer(
-        tokenAddress,
-        from,
-        to,
-        amount,
-        endpoint.chainId,
-        callOptions?.decimals,
-        endpoint.rpcUrl
-      );
-      if (!disposed && own === generation) result.value = value;
-      return value;
+      return await action(commit);
     } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error(String(cause));
+      const normalized = normalizeError ? normalizeError(cause) : cause instanceof Error ? cause : new Error(fallbackMessage);
       if (!disposed && own === generation) error.value = normalized;
       throw normalized;
     } finally {
-      if (!disposed && own === generation) loading.value = false;
+      try {
+        if (options.onSettled) commit(options.onSettled);
+      } finally {
+        active--;
+        if (!disposed) busy.value = active > 0;
+      }
     }
   };
-  const reset = () => {
+  const invalidate = () => {
     generation++;
-    result.value = null;
+  };
+  const reset = () => {
+    invalidate();
+    error.value = null;
+  };
+  const clearError = () => {
     error.value = null;
-    loading.value = false;
   };
-  onScopeDispose2(() => {
+  const dispose = () => {
     disposed = true;
     generation++;
-  });
-  return { result, loading, error, simulate, reset };
+  };
+  onScopeDispose2(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);
+  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 endpoint = resolveSimulationEndpoint(
+          callOptions?.chainId,
+          unref2(options.chainId),
+          callOptions?.rpcUrl,
+          fallbackRpcUrl
+        );
+        manager ??= new SimulationManager({
+          enabled: true,
+          rpcUrl: fallbackRpcUrl,
+          autoSimulate: false
+        });
+        const value = await manager.simulateERC20Transfer(
+          tokenAddress,
+          from,
+          to,
+          amount,
+          endpoint.chainId,
+          callOptions?.decimals,
+          endpoint.rpcUrl
+        );
+        commit(() => {
+          result.value = value;
+        });
+        return value;
+      },
+      "Simulation failed",
+      (cause) => cause instanceof Error ? cause : new Error(String(cause)),
+      {
+        onSettled: () => {
+          loading.value = false;
+        }
+      }
+    );
+  };
+  const reset = () => {
+    guard.reset();
+    result.value = null;
+    loading.value = false;
+  };
+  return { result, loading, error: guard.error, simulate, reset };
 }
 
 // src/useTransactionSimulation.ts
 import {
   simulateTransactionPreview
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef3, toValue as toValue2, unref as unref3, watch } from "vue";
+import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef4, toValue as toValue2, unref as unref3, watch } from "vue";
 function useTransactionSimulation(tx, options = {}) {
-  const result = shallowRef3(void 0);
-  const isSimulating = shallowRef3(false);
-  const error = shallowRef3(null);
+  const guard = useActionGuard();
+  const result = shallowRef4(void 0);
+  const isSimulating = shallowRef4(false);
   let timer;
-  let generation = 0;
-  let disposed = false;
   const simulate = async () => {
-    const own = ++generation;
     const transaction = toValue2(tx);
-    if (transaction) {
-      isSimulating.value = true;
-      error.value = null;
-    }
-    try {
-      const value = await simulateTransactionPreview(transaction, {
-        chainId: unref3(options.chainId),
-        currentChain: unref3(options.currentChain),
-        publicClient: unref3(options.publicClient),
-        evmAccount: unref3(options.evmAccount)
-      });
-      if (!disposed && own === generation) result.value = value;
-      return value;
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Simulation failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      if (transaction && !disposed && own === generation)
-        isSimulating.value = false;
-    }
+    if (transaction) isSimulating.value = true;
+    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)
+        });
+        commit(() => {
+          result.value = value;
+        });
+        return value;
+      },
+      "Simulation failed",
+      void 0,
+      {
+        keepError: !transaction,
+        onSettled: transaction ? () => {
+          isSimulating.value = false;
+        } : void 0
+      }
+    );
   };
   watch(
     [
@@ -395,9 +441,12 @@ function useTransactionSimulation(tx, options = {}) {
       () => unref3(options.evmAccount)
     ],
     ([transaction]) => {
-      generation++;
+      guard.invalidate();
       if (timer) clearTimeout(timer);
-      if (!transaction) return;
+      if (!transaction) {
+        isSimulating.value = false;
+        return;
+      }
       timer = setTimeout(() => {
         timer = void 0;
         void simulate().catch(() => {
@@ -407,17 +456,14 @@ function useTransactionSimulation(tx, options = {}) {
     { immediate: true }
   );
   const reset = () => {
-    generation++;
+    guard.reset();
     result.value = void 0;
-    error.value = null;
     isSimulating.value = false;
   };
   onScopeDispose3(() => {
-    disposed = true;
-    generation++;
     if (timer) clearTimeout(timer);
   });
-  return { result, isSimulating, error, simulate, reset };
+  return { result, isSimulating, error: guard.error, simulate, reset };
 }
 
 // src/useERC20Transfer.ts
@@ -432,7 +478,7 @@ import {
   parseUnits,
   WalletError as WalletError2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose4, shallowRef as shallowRef4, toValue as toValue3, unref as unref4, watch as watch2 } from "vue";
+import { onScopeDispose as onScopeDispose4, shallowRef as shallowRef5, toValue as toValue3, unref as unref4, watch as watch2 } from "vue";
 
 // src/erc20.ts
 import {
@@ -457,8 +503,8 @@ function assertErc20Context(token, chainId, account, connected) {
 function useERC20Transfer(options) {
   const initialToken = toValue3(options.token);
   const decimals = createDecimalsCache(initialToken, initialToken.decimals);
-  const isSending = shallowRef4(false);
-  const error = shallowRef4(null);
+  const isSending = shallowRef5(false);
+  const error = shallowRef5(null);
   let generation = 0;
   let disposed = false;
   watch2(
@@ -553,7 +599,7 @@ import {
 import {
   computed as computed3,
   onScopeDispose as onScopeDispose5,
-  shallowRef as shallowRef5,
+  shallowRef as shallowRef6,
   toValue as toValue4,
   unref as unref5,
   watch as watch3
@@ -562,10 +608,10 @@ var MAX_UINT256 = (1n << 256n) - 1n;
 function useERC20Approve(options) {
   const initialToken = toValue4(options.token);
   const decimals = createDecimalsCache2(initialToken, initialToken.decimals);
-  const allowanceRaw = shallowRef5(null);
-  const isApproving = shallowRef5(false);
-  const isFetchingAllowance = shallowRef5(false);
-  const error = shallowRef5(null);
+  const allowanceRaw = shallowRef6(null);
+  const isApproving = shallowRef6(false);
+  const isFetchingAllowance = shallowRef6(false);
+  const error = shallowRef6(null);
   let generation = 0;
   let allowanceGeneration = 0;
   let disposed = false;
@@ -786,7 +832,7 @@ function useAccount(accounts, connected) {
 }
 
 // src/useSession.ts
-import { computed as computed6, shallowRef as shallowRef6, toValue as toValue7, watch as watch4 } from "vue";
+import { computed as computed6, shallowRef as shallowRef7, toValue as toValue7, watch as watch4 } from "vue";
 function readSession(manager) {
   const bundle = manager?.getActiveBundle();
   if (!bundle) {
@@ -805,7 +851,7 @@ function readSession(manager) {
   };
 }
 function useSession(manager) {
-  const snapshot = shallowRef6(readSession(toValue7(manager)));
+  const snapshot = shallowRef7(readSession(toValue7(manager)));
   watch4(
     () => toValue7(manager),
     (current, _previous, onCleanup) => {
@@ -841,50 +887,6 @@ 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";
-
-// src/internal/action-guard.ts
-import { onScopeDispose as onScopeDispose6, shallowRef as shallowRef7 } from "vue";
-function useActionGuard() {
-  const busy = shallowRef7(false);
-  const error = shallowRef7(null);
-  let active = 0;
-  let generation = 0;
-  let disposed = false;
-  const run = async (action, fallbackMessage, normalizeError) => {
-    const own = ++generation;
-    const commit = (write) => {
-      if (!disposed && own === generation) write();
-    };
-    active++;
-    busy.value = true;
-    error.value = null;
-    try {
-      return await action(commit);
-    } catch (cause) {
-      const normalized = normalizeError ? normalizeError(cause) : cause instanceof Error ? cause : new Error(fallbackMessage);
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) busy.value = active > 0;
-    }
-  };
-  const reset = () => {
-    generation++;
-    error.value = null;
-  };
-  const clearError = () => {
-    error.value = null;
-  };
-  const dispose = () => {
-    disposed = true;
-    generation++;
-  };
-  onScopeDispose6(dispose);
-  return { busy, error, run, clearError, reset, dispose };
-}
-
-// src/useConnect.ts
 function useConnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
@@ -1052,46 +1054,32 @@ function useSolanaTransaction(options) {
 }
 
 // src/useSignInWithX.ts
-import { onScopeDispose as onScopeDispose7, shallowRef as shallowRef10, unref as unref12 } from "vue";
+import { shallowRef as shallowRef10, unref as unref12 } from "vue";
 function useSignInWithX(action) {
-  const isSigningIn = shallowRef10(false);
+  const guard = useActionGuard();
   const result = shallowRef10(null);
-  const error = shallowRef10(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const signIn = async (options) => {
+  const signIn = (options) => {
     const invoke = unref12(action);
-    const own = ++generation;
-    active++;
-    isSigningIn.value = true;
-    error.value = null;
-    try {
+    return guard.run(async (commit) => {
       const next = await invoke(options);
-      if (!disposed && own === generation) result.value = next;
+      commit(() => {
+        result.value = next;
+      });
       return next;
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("SIWX sign-in failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) isSigningIn.value = active > 0;
-    }
-  };
-  const clearError = () => {
-    error.value = null;
+    }, "SIWX sign-in failed");
   };
   const reset = () => {
-    generation++;
+    guard.reset();
     result.value = null;
-    error.value = null;
   };
-  onScopeDispose7(() => {
-    disposed = true;
-    generation++;
-  });
-  return { signIn, isSigningIn, result, error, clearError, reset };
+  return {
+    signIn,
+    isSigningIn: guard.busy,
+    result,
+    error: guard.error,
+    clearError: guard.clearError,
+    reset
+  };
 }
 
 // src/useSignInWithEthereum.ts
@@ -1131,7 +1119,7 @@ import {
 } from "@naculus/connect-appkit-core";
 import {
   computed as computed12,
-  onScopeDispose as onScopeDispose9,
+  onScopeDispose as onScopeDispose7,
   shallowRef as shallowRef12,
   toValue as toValue13,
   unref as unref14,
@@ -1140,7 +1128,7 @@ import {
 
 // src/useSessionKeys.ts
 import { getSharedSessionKeyManager } from "@naculus/connect-appkit-core";
-import { computed as computed11, onScopeDispose as onScopeDispose8, shallowRef as shallowRef11, toValue as toValue12, watch as watch5 } from "vue";
+import { computed as computed11, onScopeDispose as onScopeDispose6, shallowRef as shallowRef11, toValue as toValue12, watch as watch5 } from "vue";
 function resolveManager(config, options) {
   return options.manager ?? getSharedSessionKeyManager(config);
 }
@@ -1177,7 +1165,7 @@ function useSessionKeys(connected, config, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose8(() => {
+  onScopeDispose6(() => {
     disposed = true;
     generation++;
   });
@@ -1264,6 +1252,10 @@ function useDelegationPolicy(options) {
     previewExecution: (callCount, atomicity) => unref14(options.previewExecution)(callCount, atomicity),
     sponsorship: options.sponsorship,
     adapter: options.adapter,
+    signTypedData: options.signTypedData ? (typedData) => unref14(
+      options.signTypedData
+    )(typedData) : void 0,
+    chainId: () => toValue13(options.chainId) ?? null,
     delegation: () => toValue13(options.delegation),
     encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
     storageAvailable: () => sessionKeys.storageAvailable,
@@ -1299,7 +1291,7 @@ function useDelegationPolicy(options) {
     },
     { immediate: true }
   );
-  onScopeDispose9(() => {
+  onScopeDispose7(() => {
     disposed = true;
     verifyGeneration++;
   });
@@ -1342,7 +1334,7 @@ import {
 import { WalletError as WalletError5 } from "@naculus/connect-core";
 import {
   computed as computed13,
-  onScopeDispose as onScopeDispose10,
+  onScopeDispose as onScopeDispose8,
   shallowRef as shallowRef13,
   toValue as toValue14,
   unref as unref15,
@@ -1473,7 +1465,7 @@ function useSmartAccount(options) {
     });
     return addr;
   }, "Failed to get smart account address");
-  onScopeDispose10(() => {
+  onScopeDispose8(() => {
     disposed = true;
     generation++;
   });
@@ -1497,7 +1489,7 @@ import {
   resolveUserOpChain
 } from "@naculus/connect-appkit-core";
 import { WalletError as WalletError6 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef14, toValue as toValue15, unref as unref16 } from "vue";
+import { onScopeDispose as onScopeDispose9, shallowRef as shallowRef14, toValue as toValue15, unref as unref16 } from "vue";
 function useSendUserOperation(options) {
   const userOpHash = shallowRef14(null);
   const receipt = shallowRef14(null);
@@ -1588,7 +1580,7 @@ function useSendUserOperation(options) {
     isEstimating.value = false;
     error.value = null;
   };
-  onScopeDispose11(() => {
+  onScopeDispose9(() => {
     disposed = true;
     requestId++;
   });
@@ -1608,7 +1600,7 @@ import {
   fetchUserOperationReceipt,
   InvalidUserOperationReceiptError
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose12, shallowRef as shallowRef15, toValue as toValue16 } from "vue";
+import { onScopeDispose as onScopeDispose10, shallowRef as shallowRef15, toValue as toValue16 } from "vue";
 function useUserOpStatus(options) {
   const status = shallowRef15("idle");
   const receipt = shallowRef15(null);
@@ -1722,7 +1714,7 @@ function useUserOpStatus(options) {
     attempts.value = 0;
     elapsedMs.value = 0;
   };
-  onScopeDispose12(stop);
+  onScopeDispose10(stop);
   return {
     status,
     receipt,
@@ -1738,7 +1730,7 @@ function useUserOpStatus(options) {
 }
 
 // src/useSendCalls.ts
-import { computed as computed14, onScopeDispose as onScopeDispose13, shallowRef as shallowRef16, toValue as toValue17, unref as unref17 } from "vue";
+import { computed as computed14, onScopeDispose as onScopeDispose11, shallowRef as shallowRef16, toValue as toValue17, unref as unref17 } from "vue";
 function useSendCalls(options) {
   const status = shallowRef16("idle");
   const error = shallowRef16(null);
@@ -1785,7 +1777,7 @@ function useSendCalls(options) {
     batchHash.value = null;
     callsStatus.value = null;
   };
-  onScopeDispose13(() => {
+  onScopeDispose11(() => {
     disposed = true;
     sendGeneration++;
     statusGeneration++;
@@ -1897,37 +1889,45 @@ 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 onScopeDispose14, shallowRef as shallowRef17, toValue as toValue21, watch as watch8 } from "vue";
+import { computed as computed18, onScopeDispose as onScopeDispose12, shallowRef as shallowRef17, toValue as toValue21, watch as watch8 } from "vue";
 function useBalance(account, client, options = {}) {
+  const guard = useActionGuard();
   const balance = shallowRef17(null);
   const isFetching = shallowRef17(false);
-  const error = shallowRef17(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const refetch = async () => {
     const reader = toValue21(client);
     const address = bareEvmAddress5(toValue21(account));
-    const own = ++generation;
     if (!reader || !address) {
+      guard.reset();
       balance.value = null;
-      error.value = null;
       isFetching.value = false;
       return;
     }
     isFetching.value = true;
-    error.value = null;
-    try {
-      const next = await reader.getBalance({ address });
-      if (disposed || own !== generation) return;
-      balance.value = next.toString();
-    } catch (cause) {
-      if (disposed || own !== generation) return;
-      balance.value = null;
-      error.value = cause instanceof Error ? cause : new Error("Balance read failed");
-    } finally {
-      if (!disposed && own === generation) isFetching.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          const next = await reader.getBalance({ address });
+          commit(() => {
+            balance.value = next.toString();
+          });
+        } catch (cause) {
+          commit(() => {
+            balance.value = null;
+          });
+          throw cause;
+        }
+      },
+      "Balance read failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   const stopTimer = () => {
     if (timer) clearInterval(timer);
@@ -1946,11 +1946,7 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose14(() => {
-    disposed = true;
-    generation++;
-    stopTimer();
-  });
+  onScopeDispose12(stopTimer);
   return {
     balance,
     formatted: computed18(
@@ -1958,7 +1954,7 @@ function useBalance(account, client, options = {}) {
     ),
     symbol: computed18(() => toValue21(options.symbol) ?? null),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
@@ -1967,47 +1963,66 @@ function useBalance(account, client, options = {}) {
 import {
   isQuotableInput
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef18, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
+import { onScopeDispose as onScopeDispose13, shallowRef as shallowRef18, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
 function useRouteQuote(input, getQuotes, options = {}) {
+  const guard = useActionGuard();
   const quotes = shallowRef18([]);
   const loading = shallowRef18(false);
-  const error = shallowRef18(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const clearTimer = () => {
     if (timer) clearTimeout(timer);
     timer = null;
   };
-  const fetchQuotes = async () => {
-    const current = toValue22(input);
-    const fn = unref21(getQuotes);
-    const own = ++generation;
+  const requestable = (current) => {
     if (!isQuotableInput(current)) {
+      guard.invalidate();
+      loading.value = false;
       quotes.value = [];
-      return;
+      return null;
     }
+    const fn = unref21(getQuotes);
+    if (!fn) {
+      guard.invalidate();
+      loading.value = false;
+      return null;
+    }
+    return fn;
+  };
+  const fetchQuotes = async () => {
+    const current = toValue22(input);
+    const fn = requestable(current);
     if (!fn) return;
     loading.value = true;
-    error.value = null;
-    try {
-      const result = await fn(
-        current.fromChain,
-        current.toChain,
-        current.fromToken,
-        current.amount,
-        current.options,
-        current.toToken
-      );
-      if (disposed || own !== generation) return;
-      quotes.value = result;
-    } catch (cause) {
-      if (disposed || own !== generation) return;
-      error.value = cause instanceof Error ? cause : new Error(String(cause));
-      quotes.value = [];
-    } finally {
-      if (!disposed && own === generation) loading.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          const result = await fn(
+            current.fromChain,
+            current.toChain,
+            current.fromToken,
+            current.amount,
+            current.options,
+            current.toToken
+          );
+          commit(() => {
+            quotes.value = result;
+          });
+        } catch (cause) {
+          commit(() => {
+            quotes.value = [];
+          });
+          throw cause;
+        }
+      },
+      "Route quote failed",
+      (cause) => cause instanceof Error ? cause : new Error(String(cause)),
+      {
+        onSettled: () => {
+          loading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   watch9(
     [
@@ -2018,12 +2033,10 @@ function useRouteQuote(input, getQuotes, options = {}) {
       () => toValue22(input).amount,
       () => unref21(getQuotes)
     ],
-    ([fromChain, toChain, fromToken, , amount]) => {
+    () => {
       clearTimer();
-      if (!fromChain || !toChain || !fromToken || !amount) {
-        quotes.value = [];
-        return;
-      }
+      guard.invalidate();
+      if (!requestable(toValue22(input))) return;
       timer = setTimeout(() => {
         timer = null;
         void fetchQuotes();
@@ -2031,21 +2044,16 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose15(() => {
-    disposed = true;
-    generation++;
-    clearTimer();
-  });
+  onScopeDispose13(clearTimer);
   return {
     quotes,
     loading,
-    error,
+    error: guard.error,
     refresh: fetchQuotes,
     clear: () => {
       clearTimer();
-      generation++;
+      guard.reset();
       quotes.value = [];
-      error.value = null;
       loading.value = false;
     }
   };
@@ -2055,35 +2063,49 @@ function useRouteQuote(input, getQuotes, options = {}) {
 import {
   compareCostsKey
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef19, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
+import { shallowRef as shallowRef19, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
 function useCompareCosts(input, compareCosts) {
+  const guard = useActionGuard();
   const comparisons = shallowRef19([]);
   const loading = shallowRef19(false);
-  const error = shallowRef19(null);
-  let generation = 0;
-  let disposed = false;
   const fetchComparisons = async () => {
     const { operation, chains, options } = toValue23(input);
     const fn = unref22(compareCosts);
-    const own = ++generation;
     if (!chains || chains.length === 0) {
+      guard.invalidate();
+      loading.value = false;
       comparisons.value = [];
       return;
     }
-    if (!fn) return;
-    loading.value = true;
-    error.value = null;
-    try {
-      const result = await fn(operation, chains, options);
-      if (disposed || own !== generation) return;
-      comparisons.value = result;
-    } catch (cause) {
-      if (disposed || own !== generation) return;
-      error.value = cause instanceof Error ? cause : new Error(String(cause));
-      comparisons.value = [];
-    } finally {
-      if (!disposed && own === generation) loading.value = false;
+    if (!fn) {
+      guard.invalidate();
+      loading.value = false;
+      return;
     }
+    loading.value = true;
+    await guard.run(
+      async (commit) => {
+        try {
+          const result = await fn(operation, chains, options);
+          commit(() => {
+            comparisons.value = result;
+          });
+        } catch (cause) {
+          commit(() => {
+            comparisons.value = [];
+          });
+          throw cause;
+        }
+      },
+      "Cost comparison failed",
+      (cause) => cause instanceof Error ? cause : new Error(String(cause)),
+      {
+        onSettled: () => {
+          loading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   watch10(
     [() => compareCostsKey(toValue23(input)), () => unref22(compareCosts)],
@@ -2092,11 +2114,12 @@ function useCompareCosts(input, compareCosts) {
     },
     { immediate: true }
   );
-  onScopeDispose16(() => {
-    disposed = true;
-    generation++;
-  });
-  return { comparisons, loading, error, refresh: fetchComparisons };
+  return {
+    comparisons,
+    loading,
+    error: guard.error,
+    refresh: fetchComparisons
+  };
 }
 
 // src/useExecuteRoute.ts
@@ -2104,7 +2127,7 @@ import {
   toExecuteRouteError,
   validateRouteRecipient
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef20, unref as unref23 } from "vue";
+import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef20, unref as unref23 } from "vue";
 function useExecuteRoute(executeRoute) {
   const executing = shallowRef20(false);
   const result = shallowRef20(null);
@@ -2150,7 +2173,7 @@ function useExecuteRoute(executeRoute) {
       if (!disposed) executing.value = false;
     }
   };
-  onScopeDispose17(() => {
+  onScopeDispose14(() => {
     disposed = true;
   });
   return {
@@ -2171,17 +2194,15 @@ import { eip155ChainIdToNumber } from "@naculus/connect-appkit-core";
 import {
   TokenListManager
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef21, toValue as toValue24, watch as watch11 } from "vue";
+import { shallowRef as shallowRef21, toValue as toValue24, watch as watch11 } 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 error = shallowRef21(null);
-  let generation = 0;
-  let disposed = false;
   const select = () => {
     const id = toValue24(chainId);
     const numeric = id ? eip155ChainIdToNumber(id) : void 0;
@@ -2190,20 +2211,24 @@ function useTokenList(chainId, options = {}) {
     );
   };
   const run = async (op) => {
-    const own = ++generation;
     isLoading.value = true;
-    error.value = null;
-    try {
-      await op();
-      if (disposed || own !== generation) return;
-      tokens.value = select();
-      isLoaded.value = true;
-    } catch (cause) {
-      if (disposed || own !== generation) return;
-      error.value = cause instanceof Error ? cause : new Error(String(cause));
-    } finally {
-      if (!disposed && own === generation) isLoading.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        await op();
+        commit(() => {
+          tokens.value = select();
+          isLoaded.value = true;
+        });
+      },
+      "Token list load failed",
+      (cause) => cause instanceof Error ? cause : new Error(String(cause)),
+      {
+        onSettled: () => {
+          isLoading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   watch11(
     () => toValue24(chainId),
@@ -2212,15 +2237,11 @@ function useTokenList(chainId, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose18(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     tokens,
     isLoading,
     isLoaded,
-    error,
+    error: guard.error,
     refetch: () => run(() => manager.refresh())
   };
 }
@@ -2230,7 +2251,7 @@ import { eip155ChainIdToNumber as eip155ChainIdToNumber2 } from "@naculus/connec
 import {
   TokenListManager as TokenListManager2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef22, toValue as toValue25, watch as watch12 } from "vue";
+import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef22, toValue as toValue25, watch as watch12 } from "vue";
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
@@ -2273,7 +2294,7 @@ function useTokenSearch(query, chainId, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose19(clear);
+  onScopeDispose15(clear);
   return { results, isSearching };
 }
 
@@ -2291,60 +2312,68 @@ 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 onScopeDispose20, shallowRef as shallowRef23, toValue as toValue27, watch as watch13 } from "vue";
+import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef23, toValue as toValue27, watch as watch13 } 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 error = shallowRef23(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const refetch = async () => {
     const reader = toValue27(client);
     const address = bareEvmAddress6(toValue27(account));
     const list = toValue27(tokens) ?? [];
-    const own = ++generation;
     if (!reader || !address || list.length === 0) {
+      guard.reset();
       tokenBalances.value = [];
-      error.value = null;
       isFetching.value = false;
       return;
     }
     isFetching.value = true;
-    error.value = null;
-    try {
-      const results = await Promise.all(
-        list.map(async (token) => {
-          try {
-            const raw = await reader.readContract({
-              address: token.address,
-              abi: ERC20_MIN_ABI3,
-              functionName: "balanceOf",
-              args: [address]
-            });
-            const value = BigInt(raw);
-            return {
-              ...token,
-              balance: value.toString(),
-              formatted: formatUnits3(value, token.decimals)
-            };
-          } catch {
-            return { ...token, balance: null, formatted: null };
-          }
-        })
-      );
-      if (disposed || own !== generation) return;
-      tokenBalances.value = results;
-    } catch (cause) {
-      if (disposed || own !== generation) return;
-      tokenBalances.value = [];
-      error.value = cause instanceof Error ? cause : new Error("Failed to fetch token balances");
-    } finally {
-      if (!disposed && own === generation) isFetching.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          const results = await Promise.all(
+            list.map(async (token) => {
+              try {
+                const raw = await reader.readContract({
+                  address: token.address,
+                  abi: ERC20_MIN_ABI3,
+                  functionName: "balanceOf",
+                  args: [address]
+                });
+                const value = BigInt(raw);
+                return {
+                  ...token,
+                  balance: value.toString(),
+                  formatted: formatUnits3(value, token.decimals)
+                };
+              } catch {
+                return { ...token, balance: null, formatted: null };
+              }
+            })
+          );
+          commit(() => {
+            tokenBalances.value = results;
+          });
+        } catch (cause) {
+          commit(() => {
+            tokenBalances.value = [];
+          });
+          throw cause;
+        }
+      },
+      "Failed to fetch token balances",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   const stopTimer = () => {
     if (timer) clearInterval(timer);
@@ -2364,15 +2393,11 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose20(() => {
-    disposed = true;
-    generation++;
-    stopTimer();
-  });
+  onScopeDispose16(stopTimer);
   return {
     tokenBalances,
     isFetching,
-    error,
+    error: guard.error,
     refetch,
     getTokenBalance: (tokenAddress) => tokenBalances.value.find(
       (t) => t.address.toLowerCase() === tokenAddress.toLowerCase()
@@ -2388,7 +2413,7 @@ import {
   REVOKE_DELEGATE,
   WalletError as WalletError7
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose21, shallowRef as shallowRef24, toValue as toValue28, watch as watch14 } from "vue";
+import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef24, toValue as toValue28, watch as watch14 } from "vue";
 function useDelegate(options) {
   const result = shallowRef24(null);
   const isPending = shallowRef24(false);
@@ -2463,7 +2488,7 @@ function useDelegate(options) {
     reset,
     { flush: "sync" }
   );
-  onScopeDispose21(() => {
+  onScopeDispose17(() => {
     disposed = true;
     requestId++;
   });
@@ -2483,37 +2508,44 @@ import {
   readDelegation,
   UNKNOWN_DELEGATION
 } from "@naculus/connect-core";
-import { computed as computed20, onScopeDispose as onScopeDispose22, shallowRef as shallowRef25, toValue as toValue29, watch as watch15 } from "vue";
+import { computed as computed20, shallowRef as shallowRef25, toValue as toValue29, watch as watch15 } from "vue";
 function useDelegation(account, client, chainId) {
+  const guard = useActionGuard();
   const status = shallowRef25(UNKNOWN_DELEGATION);
   const isFetching = shallowRef25(false);
-  const error = shallowRef25(null);
-  let generation = 0;
-  let disposed = false;
   const refetch = async () => {
-    const mine = ++generation;
     const reader = toValue29(client);
     const address = bareEvmAddress8(toValue29(account));
     status.value = UNKNOWN_DELEGATION;
-    error.value = null;
     if (!reader || !address) {
+      guard.reset();
       isFetching.value = false;
       return;
     }
     isFetching.value = true;
-    try {
-      const code = await reader.getCode({ address });
-      if (!disposed && mine === generation) {
-        status.value = readDelegation(code ?? "0x");
-      }
-    } catch (cause) {
-      if (!disposed && mine === generation) {
-        status.value = UNKNOWN_DELEGATION;
-        error.value = cause instanceof Error ? cause : new Error("Code read failed");
+    await guard.run(
+      async (commit) => {
+        try {
+          const code = await reader.getCode({ address });
+          commit(() => {
+            status.value = readDelegation(code ?? "0x");
+          });
+        } catch (cause) {
+          commit(() => {
+            status.value = UNKNOWN_DELEGATION;
+          });
+          throw cause;
+        }
+      },
+      "Code read failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
       }
-    } finally {
-      if (!disposed && mine === generation) isFetching.value = false;
-    }
+    ).catch(() => {
+    });
   };
   watch15(
     [() => toValue29(account), () => toValue29(client), () => toValue29(chainId)],
@@ -2522,55 +2554,149 @@ function useDelegation(account, client, chainId) {
     },
     { immediate: true, flush: "sync" }
   );
-  onScopeDispose22(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     delegated: computed20(() => status.value.delegated),
     delegate: computed20(() => status.value.delegate),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
 
+// src/usePaymentFetch.ts
+import {
+  describePayment
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef26, unref as unref24 } from "vue";
+function usePaymentFetch(pay) {
+  const guard = useActionGuard();
+  const lastPayment = shallowRef26(null);
+  let epoch = 0;
+  onScopeDispose18(() => {
+    epoch++;
+  });
+  const payFetch = (input, init) => {
+    const invoke = unref24(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;
+      return result;
+    }, "Paid request failed");
+  };
+  return {
+    payFetch,
+    isPending: guard.busy,
+    lastPayment,
+    error: guard.error,
+    reset: () => {
+      epoch++;
+      guard.reset();
+      lastPayment.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";
+function useSolanaSessionKey(deps) {
+  const guard = useActionGuard();
+  const keys = shallowRef27([]);
+  let flow = null;
+  let generation = 0;
+  let disposed = false;
+  onScopeDispose19(() => {
+    disposed = true;
+  });
+  const refresh = async () => {
+    const own = ++generation;
+    const next = flow ? await flow.list() : [];
+    if (!disposed && own === generation) keys.value = next;
+  };
+  watch16(
+    () => unref25(deps),
+    (next) => {
+      flow = next ? createSolanaSessionKeyFlow(next) : null;
+      guard.invalidate();
+      void refresh().catch(() => {
+      });
+    },
+    { immediate: true }
+  );
+  const unavailable = () => Promise.reject(new Error("No Solana session key manager is connected"));
+  const act = (action, fallback) => {
+    const current = flow;
+    if (!current) return unavailable();
+    return guard.run(async () => {
+      try {
+        return await action(current);
+      } finally {
+        await refresh().catch(() => {
+        });
+      }
+    }, fallback);
+  };
+  return {
+    keys,
+    create: (scope) => act((f) => f.create(scope), "Could not create the key"),
+    revoke: (id) => act((f) => f.revoke(id), "Could not revoke the key"),
+    refresh,
+    isPending: guard.busy,
+    error: guard.error
+  };
+}
+
 // src/name-lookup.ts
 import { getResolver } from "@naculus/connect-appkit-core";
-import { computed as computed21, onScopeDispose as onScopeDispose23, shallowRef as shallowRef26, toValue as toValue30, watch as watch16 } from "vue";
+import { computed as computed21, shallowRef as shallowRef28, toValue as toValue30, watch as watch17 } from "vue";
 function useNameLookup(options) {
-  const data = shallowRef26(null);
-  const loading = shallowRef26(false);
-  const error = shallowRef26(null);
-  let generation = 0;
-  let disposed = false;
+  const guard = useActionGuard();
+  const data = shallowRef28(null);
+  const loading = shallowRef28(false);
   const run = () => {
     const input = toValue30(options.input).trim();
     const skip = toValue30(options.skip) ?? false;
     const scope = toValue30(options.scope);
     const config = toValue30(options.resolverConfig);
-    const mine = ++generation;
     if (!input || skip) {
+      guard.reset();
       data.value = null;
       loading.value = false;
-      error.value = null;
       return;
     }
     data.value = null;
     loading.value = true;
-    error.value = null;
-    Promise.resolve().then(() => options.query(getResolver(config), input, scope)).then((result) => {
-      if (disposed || mine !== generation) return;
-      data.value = result;
-      loading.value = false;
-    }).catch((cause) => {
-      if (disposed || mine !== generation) return;
-      data.value = null;
-      error.value = cause instanceof Error ? cause : new Error(String(cause));
-      loading.value = false;
+    void guard.run(
+      async (commit) => {
+        try {
+          const result = await Promise.resolve().then(
+            () => options.query(getResolver(config), input, scope)
+          );
+          commit(() => {
+            data.value = result;
+          });
+        } catch (cause) {
+          commit(() => {
+            data.value = null;
+          });
+          throw cause;
+        }
+      },
+      "Name lookup failed",
+      (cause) => cause instanceof Error ? cause : new Error(String(cause)),
+      {
+        onSettled: () => {
+          loading.value = false;
+        }
+      }
+    ).catch(() => {
     });
   };
-  watch16(
+  watch17(
     () => [
       toValue30(options.input),
       toValue30(options.skip),
@@ -2580,14 +2706,10 @@ function useNameLookup(options) {
     run,
     { immediate: true, flush: "sync", deep: true }
   );
-  onScopeDispose23(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     data,
     isLoading: computed21(() => loading.value),
-    error,
+    error: guard.error,
     refetch: run
   };
 }
@@ -2662,13 +2784,13 @@ function useChain(chains, chainId) {
 }
 
 // src/usePassphraseGate.ts
-import { onScopeDispose as onScopeDispose24, readonly, shallowRef as shallowRef27 } from "vue";
+import { onScopeDispose as onScopeDispose20, readonly, shallowRef as shallowRef29 } from "vue";
 function usePassphraseGate(gate) {
-  const request = shallowRef27(gate.getSnapshot());
+  const request = shallowRef29(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  onScopeDispose24(unsubscribe);
+  onScopeDispose20(unsubscribe);
   return {
     request: readonly(request),
     submit: (passphrase) => gate.submit(passphrase),
@@ -2678,56 +2800,61 @@ function usePassphraseGate(gate) {
 }
 
 // src/useSolanaBalance.ts
-import {
-  getSolanaBalance
-} from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose25, ref, shallowRef as shallowRef28, toValue as toValue33, watchEffect } from "vue";
+import { getSolanaBalance } from "@naculus/connect-core";
+import { ref, shallowRef as shallowRef30, toValue as toValue33, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
-  const balance = shallowRef28(null);
+  const guard = useActionGuard();
+  const balance = shallowRef30(null);
   const isFetching = ref(false);
-  const error = shallowRef28(null);
-  let generation = 0;
-  let disposed = false;
   const refetch = async () => {
     const addr = toValue33(address);
     const url = toValue33(rpcUrl);
     if (!addr || !url) {
+      guard.invalidate();
+      isFetching.value = false;
       balance.value = null;
       return;
     }
-    const own = ++generation;
     isFetching.value = true;
-    error.value = null;
-    try {
-      const next = await getSolanaBalance(url, addr);
-      if (disposed || own !== generation) return;
-      balance.value = next;
-    } catch (err) {
-      if (disposed || own !== generation) return;
-      balance.value = null;
-      error.value = err instanceof Error ? err : new Error("Balance read failed");
-    } finally {
-      if (!disposed && own === generation) isFetching.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          const next = await getSolanaBalance(url, addr);
+          commit(() => {
+            balance.value = next;
+          });
+        } catch (err) {
+          commit(() => {
+            balance.value = null;
+          });
+          throw err;
+        }
+      },
+      "Balance read failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   watchEffect(() => {
     toValue33(address);
     toValue33(rpcUrl);
     void refetch();
   });
-  onScopeDispose25(() => {
-    disposed = true;
-  });
-  return { balance, isFetching, error, refetch };
+  return { balance, isFetching, error: guard.error, refetch };
 }
 
 // src/useLastTx.ts
-import { shallowRef as shallowRef29, toValue as toValue34, watch as watch17 } from "vue";
+import { shallowRef as shallowRef31, toValue as toValue34, watch as watch18 } from "vue";
 function useLastTx(monitor) {
-  const lastTx = shallowRef29(null);
-  const lastConfirmedTx = shallowRef29(null);
-  const lastFailedTx = shallowRef29(null);
-  watch17(
+  const lastTx = shallowRef31(null);
+  const lastConfirmedTx = shallowRef31(null);
+  const lastFailedTx = shallowRef31(null);
+  watch18(
     () => toValue34(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
@@ -2766,37 +2893,41 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-import { computed as computed24, shallowRef as shallowRef30, toValue as toValue35, watch as watch18 } from "vue";
+import { computed as computed24, shallowRef as shallowRef32, toValue as toValue35, watch as watch19 } from "vue";
 function useTxHistory(address, chainId, monitor) {
-  const entries = shallowRef30([]);
-  const isLoading = shallowRef30(false);
-  const error = shallowRef30(null);
-  let generation = 0;
+  const guard = useActionGuard();
+  const entries = shallowRef32([]);
+  const isLoading = shallowRef32(false);
   const refresh = async () => {
-    const mine = ++generation;
     const activeMonitor = toValue35(monitor);
     if (!activeMonitor) {
+      guard.reset();
       entries.value = [];
       isLoading.value = false;
-      error.value = null;
       return;
     }
     isLoading.value = true;
-    error.value = null;
-    try {
-      const result = await activeMonitor.getTxHistory(
-        toValue35(address) ?? void 0,
-        toValue35(chainId) ?? void 0
-      );
-      if (mine === generation) entries.value = result;
-    } catch (err) {
-      if (mine !== generation) return;
-      error.value = err instanceof Error ? err : new Error("Failed to load transaction history");
-    } finally {
-      if (mine === generation) isLoading.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        const result = await activeMonitor.getTxHistory(
+          toValue35(address) ?? void 0,
+          toValue35(chainId) ?? void 0
+        );
+        commit(() => {
+          entries.value = result;
+        });
+      },
+      "Failed to load transaction history",
+      void 0,
+      {
+        onSettled: () => {
+          isLoading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
-  watch18(
+  watch19(
     [() => toValue35(monitor), () => toValue35(address), () => toValue35(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
@@ -2815,7 +2946,7 @@ function useTxHistory(address, chainId, monitor) {
   return {
     entries,
     isLoading,
-    error,
+    error: guard.error,
     refresh,
     summary: computed24(() => ({
       pending: entries.value.filter((item) => item.status === "pending").length,
@@ -2826,12 +2957,12 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-import { computed as computed25, shallowRef as shallowRef31, toValue as toValue36, watch as watch19 } from "vue";
+import { computed as computed25, shallowRef as shallowRef33, toValue as toValue36, watch as watch20 } from "vue";
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = shallowRef31(null);
-  const isLoading = shallowRef31(false);
-  const isWatching = shallowRef31(false);
-  const error = shallowRef31(null);
+  const entry = shallowRef33(null);
+  const isLoading = shallowRef33(false);
+  const isWatching = shallowRef33(false);
+  const error = shallowRef33(null);
   let generation = 0;
   const refresh = async () => {
     const activeMonitor = toValue36(monitor);
@@ -2861,7 +2992,7 @@ function useTxMonitor(hash, chainId, monitor) {
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  watch19(
+  watch20(
     [() => toValue36(monitor), () => toValue36(hash), () => toValue36(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
@@ -2917,37 +3048,46 @@ import {
   normalizeCapabilities,
   selectChainCapabilities
 } from "@naculus/connect-appkit-core";
-import { computed as computed26, shallowRef as shallowRef32, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
+import { computed as computed26, shallowRef as shallowRef34, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
-  const capabilities = shallowRef32(
+  const guard = useActionGuard();
+  const capabilities = shallowRef34(
     null
   );
-  const isFetching = shallowRef32(false);
-  const error = shallowRef32(null);
-  let generation = 0;
+  const isFetching = shallowRef34(false);
   const refetch = async () => {
-    const mine = ++generation;
     const activeClient = toValue37(client);
     const activeSession = toValue37(session);
     if (!activeClient?.getCapabilities || !activeSession) {
+      guard.reset();
       capabilities.value = null;
       isFetching.value = false;
-      error.value = null;
       return;
     }
     isFetching.value = true;
-    error.value = null;
-    try {
-      const raw = await activeClient.getCapabilities(activeSession);
-      if (mine !== generation) return;
-      capabilities.value = normalizeCapabilities(raw);
-    } catch (err) {
-      if (mine !== generation) return;
-      capabilities.value = null;
-      error.value = err instanceof Error ? err : new Error("Capability query failed");
-    } finally {
-      if (mine === generation) isFetching.value = false;
-    }
+    await guard.run(
+      async (commit) => {
+        try {
+          const raw = await activeClient.getCapabilities(activeSession);
+          commit(() => {
+            capabilities.value = normalizeCapabilities(raw);
+          });
+        } catch (err) {
+          commit(() => {
+            capabilities.value = null;
+          });
+          throw err;
+        }
+      },
+      "Capability query failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
   watchEffect2(() => {
     void toValue37(client);
@@ -2963,7 +3103,7 @@ function useCapabilities(client, session, chainId) {
       () => atomicSupportFor(capabilities.value, toValue37(chainId))
     ),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
@@ -3036,6 +3176,7 @@ export {
   useLookupAddress,
   useNotification,
   usePassphraseGate,
+  usePaymentFetch,
   useResolveName,
   useRevokeSession,
   useRouteQuote,
@@ -3056,6 +3197,7 @@ export {
   useSolanaAccount,
   useSolanaBalance,
   useSolanaRoles,
+  useSolanaSessionKey,
   useSolanaTransaction,
   useSwitchChain,
   useTokenBalance,