@naculus/connect-appkit-vue 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -80,6 +80,7 @@ __export(index_exports, {
   useLookupAddress: () => useLookupAddress,
   useNotification: () => useNotification,
   usePassphraseGate: () => usePassphraseGate,
+  usePaymentFetch: () => usePaymentFetch,
   useResolveName: () => useResolveName,
   useRevokeSession: () => useRevokeSession,
   useRouteQuote: () => useRouteQuote,
@@ -393,110 +394,159 @@ function useNotification(options = {}) {
 // src/useSimulateTransfer.ts
 var import_connect_appkit_core2 = require("@naculus/connect-appkit-core");
 var import_connect_core3 = require("@naculus/connect-core");
+var import_vue4 = require("vue");
+
+// src/internal/action-guard.ts
 var import_vue3 = require("vue");
-function useSimulateTransfer(options = {}) {
-  const result = (0, import_vue3.shallowRef)(null);
-  const loading = (0, import_vue3.shallowRef)(false);
+function useActionGuard() {
+  const busy = (0, import_vue3.shallowRef)(false);
   const error = (0, import_vue3.shallowRef)(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 = (0, import_vue3.unref)(options.rpcUrl);
-      const endpoint = (0, import_connect_appkit_core2.resolveSimulationEndpoint)(
-        callOptions?.chainId,
-        (0, import_vue3.unref)(options.chainId),
-        callOptions?.rpcUrl,
-        fallbackRpcUrl
-      );
-      manager ??= new import_connect_core3.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;
   };
-  (0, import_vue3.onScopeDispose)(() => {
+  const dispose = () => {
     disposed = true;
     generation++;
-  });
-  return { result, loading, error, simulate, reset };
+  };
+  (0, import_vue3.onScopeDispose)(dispose);
+  return { busy, error, run, clearError, reset, invalidate, dispose };
+}
+
+// src/useSimulateTransfer.ts
+function useSimulateTransfer(options = {}) {
+  const guard = useActionGuard();
+  const result = (0, import_vue4.shallowRef)(null);
+  const loading = (0, import_vue4.shallowRef)(false);
+  let manager;
+  const simulate = async (tokenAddress, from, to, amount, callOptions) => {
+    loading.value = true;
+    return await guard.run(
+      async (commit) => {
+        const fallbackRpcUrl = (0, import_vue4.unref)(options.rpcUrl);
+        const endpoint = (0, import_connect_appkit_core2.resolveSimulationEndpoint)(
+          callOptions?.chainId,
+          (0, import_vue4.unref)(options.chainId),
+          callOptions?.rpcUrl,
+          fallbackRpcUrl
+        );
+        manager ??= new import_connect_core3.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
 var import_connect_appkit_core3 = require("@naculus/connect-appkit-core");
-var import_vue4 = require("vue");
+var import_vue5 = require("vue");
 function useTransactionSimulation(tx, options = {}) {
-  const result = (0, import_vue4.shallowRef)(void 0);
-  const isSimulating = (0, import_vue4.shallowRef)(false);
-  const error = (0, import_vue4.shallowRef)(null);
+  const guard = useActionGuard();
+  const result = (0, import_vue5.shallowRef)(void 0);
+  const isSimulating = (0, import_vue5.shallowRef)(false);
   let timer;
-  let generation = 0;
-  let disposed = false;
   const simulate = async () => {
-    const own = ++generation;
-    const transaction = (0, import_vue4.toValue)(tx);
-    if (transaction) {
-      isSimulating.value = true;
-      error.value = null;
-    }
-    try {
-      const value = await (0, import_connect_appkit_core3.simulateTransactionPreview)(transaction, {
-        chainId: (0, import_vue4.unref)(options.chainId),
-        currentChain: (0, import_vue4.unref)(options.currentChain),
-        publicClient: (0, import_vue4.unref)(options.publicClient),
-        evmAccount: (0, import_vue4.unref)(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;
-    }
+    const transaction = (0, import_vue5.toValue)(tx);
+    if (transaction) isSimulating.value = true;
+    return await guard.run(
+      async (commit) => {
+        const value = await (0, import_connect_appkit_core3.simulateTransactionPreview)(transaction, {
+          chainId: (0, import_vue5.unref)(options.chainId),
+          currentChain: (0, import_vue5.unref)(options.currentChain),
+          publicClient: (0, import_vue5.unref)(options.publicClient),
+          evmAccount: (0, import_vue5.unref)(options.evmAccount)
+        });
+        commit(() => {
+          result.value = value;
+        });
+        return value;
+      },
+      "Simulation failed",
+      void 0,
+      {
+        keepError: !transaction,
+        onSettled: transaction ? () => {
+          isSimulating.value = false;
+        } : void 0
+      }
+    );
   };
-  (0, import_vue4.watch)(
+  (0, import_vue5.watch)(
     [
-      () => (0, import_vue4.toValue)(tx),
-      () => (0, import_vue4.unref)(options.chainId),
-      () => (0, import_vue4.unref)(options.currentChain),
-      () => (0, import_vue4.unref)(options.publicClient),
-      () => (0, import_vue4.unref)(options.evmAccount)
+      () => (0, import_vue5.toValue)(tx),
+      () => (0, import_vue5.unref)(options.chainId),
+      () => (0, import_vue5.unref)(options.currentChain),
+      () => (0, import_vue5.unref)(options.publicClient),
+      () => (0, import_vue5.unref)(options.evmAccount)
     ],
     ([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(() => {
@@ -506,23 +556,20 @@ function useTransactionSimulation(tx, options = {}) {
     { immediate: true }
   );
   const reset = () => {
-    generation++;
+    guard.reset();
     result.value = void 0;
-    error.value = null;
     isSimulating.value = false;
   };
-  (0, import_vue4.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
+  (0, import_vue5.onScopeDispose)(() => {
     if (timer) clearTimeout(timer);
   });
-  return { result, isSimulating, error, simulate, reset };
+  return { result, isSimulating, error: guard.error, simulate, reset };
 }
 
 // src/useERC20Transfer.ts
 var import_connect_appkit_core5 = require("@naculus/connect-appkit-core");
 var import_connect_core5 = require("@naculus/connect-core");
-var import_vue5 = require("vue");
+var import_vue6 = require("vue");
 
 // src/erc20.ts
 var import_connect_appkit_core4 = require("@naculus/connect-appkit-core");
@@ -542,22 +589,22 @@ function assertErc20Context(token, chainId, account, connected) {
 
 // src/useERC20Transfer.ts
 function useERC20Transfer(options) {
-  const initialToken = (0, import_vue5.toValue)(options.token);
+  const initialToken = (0, import_vue6.toValue)(options.token);
   const decimals = (0, import_connect_appkit_core5.createDecimalsCache)(initialToken, initialToken.decimals);
-  const isSending = (0, import_vue5.shallowRef)(false);
-  const error = (0, import_vue5.shallowRef)(null);
+  const isSending = (0, import_vue6.shallowRef)(false);
+  const error = (0, import_vue6.shallowRef)(null);
   let generation = 0;
   let disposed = false;
-  (0, import_vue5.watch)(
+  (0, import_vue6.watch)(
     [
-      () => (0, import_vue5.toValue)(options.token).address,
-      () => (0, import_vue5.toValue)(options.token).chainId,
-      () => (0, import_vue5.toValue)(options.token).decimals,
-      () => (0, import_vue5.toValue)(options.account),
-      () => (0, import_vue5.toValue)(options.chainId),
-      () => (0, import_vue5.toValue)(options.connected),
-      () => (0, import_vue5.toValue)(options.publicClient),
-      () => (0, import_vue5.unref)(options.sendTransaction)
+      () => (0, import_vue6.toValue)(options.token).address,
+      () => (0, import_vue6.toValue)(options.token).chainId,
+      () => (0, import_vue6.toValue)(options.token).decimals,
+      () => (0, import_vue6.toValue)(options.account),
+      () => (0, import_vue6.toValue)(options.chainId),
+      () => (0, import_vue6.toValue)(options.connected),
+      () => (0, import_vue6.toValue)(options.publicClient),
+      () => (0, import_vue6.unref)(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -568,17 +615,17 @@ function useERC20Transfer(options) {
   );
   const sendTransfer = async (to, amount) => {
     const own = ++generation;
-    const token = (0, import_vue5.toValue)(options.token);
-    const reader = (0, import_vue5.toValue)(options.publicClient);
+    const token = (0, import_vue6.toValue)(options.token);
+    const reader = (0, import_vue6.toValue)(options.publicClient);
     const stillCurrent = () => !disposed && own === generation;
     error.value = null;
     isSending.value = true;
     try {
       assertErc20Context(
         token,
-        (0, import_vue5.toValue)(options.chainId),
-        (0, import_vue5.toValue)(options.account),
-        (0, import_vue5.toValue)(options.connected)
+        (0, import_vue6.toValue)(options.chainId),
+        (0, import_vue6.toValue)(options.account),
+        (0, import_vue6.toValue)(options.connected)
       );
       if (!reader) {
         throw new import_connect_core5.WalletError(
@@ -604,7 +651,7 @@ function useERC20Transfer(options) {
         (0, import_connect_appkit_core5.writeDecimals)(decimals, token, precision);
       }
       const data = (0, import_connect_appkit_core5.encodeErc20Transfer)(to, (0, import_connect_core5.parseUnits)(amount, precision));
-      return await (0, import_vue5.unref)(options.sendTransaction)({
+      return await (0, import_vue6.unref)(options.sendTransaction)({
         to: token.address,
         data,
         value: "0"
@@ -617,7 +664,7 @@ function useERC20Transfer(options) {
       if (stillCurrent()) isSending.value = false;
     }
   };
-  (0, import_vue5.onScopeDispose)(() => {
+  (0, import_vue6.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -627,29 +674,29 @@ function useERC20Transfer(options) {
 // src/useERC20Approve.ts
 var import_connect_appkit_core6 = require("@naculus/connect-appkit-core");
 var import_connect_core6 = require("@naculus/connect-core");
-var import_vue6 = require("vue");
+var import_vue7 = require("vue");
 var MAX_UINT256 = (1n << 256n) - 1n;
 function useERC20Approve(options) {
-  const initialToken = (0, import_vue6.toValue)(options.token);
+  const initialToken = (0, import_vue7.toValue)(options.token);
   const decimals = (0, import_connect_appkit_core6.createDecimalsCache)(initialToken, initialToken.decimals);
-  const allowanceRaw = (0, import_vue6.shallowRef)(null);
-  const isApproving = (0, import_vue6.shallowRef)(false);
-  const isFetchingAllowance = (0, import_vue6.shallowRef)(false);
-  const error = (0, import_vue6.shallowRef)(null);
+  const allowanceRaw = (0, import_vue7.shallowRef)(null);
+  const isApproving = (0, import_vue7.shallowRef)(false);
+  const isFetchingAllowance = (0, import_vue7.shallowRef)(false);
+  const error = (0, import_vue7.shallowRef)(null);
   let generation = 0;
   let allowanceGeneration = 0;
   let disposed = false;
-  (0, import_vue6.watch)(
+  (0, import_vue7.watch)(
     [
-      () => (0, import_vue6.toValue)(options.token).address,
-      () => (0, import_vue6.toValue)(options.token).chainId,
-      () => (0, import_vue6.toValue)(options.token).decimals,
-      () => (0, import_vue6.toValue)(options.spender),
-      () => (0, import_vue6.toValue)(options.account),
-      () => (0, import_vue6.toValue)(options.chainId),
-      () => (0, import_vue6.toValue)(options.connected),
-      () => (0, import_vue6.toValue)(options.publicClient),
-      () => (0, import_vue6.unref)(options.sendTransaction)
+      () => (0, import_vue7.toValue)(options.token).address,
+      () => (0, import_vue7.toValue)(options.token).chainId,
+      () => (0, import_vue7.toValue)(options.token).decimals,
+      () => (0, import_vue7.toValue)(options.spender),
+      () => (0, import_vue7.toValue)(options.account),
+      () => (0, import_vue7.toValue)(options.chainId),
+      () => (0, import_vue7.toValue)(options.connected),
+      () => (0, import_vue7.toValue)(options.publicClient),
+      () => (0, import_vue7.unref)(options.sendTransaction)
     ],
     () => {
       generation++;
@@ -662,17 +709,17 @@ function useERC20Approve(options) {
     { flush: "sync" }
   );
   const context = () => {
-    const token = (0, import_vue6.toValue)(options.token);
+    const token = (0, import_vue7.toValue)(options.token);
     const account = assertErc20Context(
       token,
-      (0, import_vue6.toValue)(options.chainId),
-      (0, import_vue6.toValue)(options.account),
-      (0, import_vue6.toValue)(options.connected)
+      (0, import_vue7.toValue)(options.chainId),
+      (0, import_vue7.toValue)(options.account),
+      (0, import_vue7.toValue)(options.connected)
     );
-    const reader = (0, import_vue6.toValue)(options.publicClient);
+    const reader = (0, import_vue7.toValue)(options.publicClient);
     if (!reader)
       throw new import_connect_core6.WalletError("wallet_unavailable", "No public client");
-    return { token, account, reader, spender: (0, import_vue6.toValue)(options.spender) };
+    return { token, account, reader, spender: (0, import_vue7.toValue)(options.spender) };
   };
   const readPrecision = async () => {
     const { token, reader } = context();
@@ -723,7 +770,7 @@ function useERC20Approve(options) {
     isApproving.value = true;
     try {
       const { token, spender } = context();
-      const hash = await (0, import_vue6.unref)(options.sendTransaction)({
+      const hash = await (0, import_vue7.unref)(options.sendTransaction)({
         to: token.address,
         data: (0, import_connect_appkit_core6.encodeErc20Approve)(spender, rawAmount),
         value: "0"
@@ -764,13 +811,13 @@ function useERC20Approve(options) {
     if (raw === null) return false;
     return raw >= (0, import_connect_core6.parseUnits)(required, await readPrecision());
   };
-  const allowance = (0, import_vue6.computed)(() => {
+  const allowance = (0, import_vue7.computed)(() => {
     if (allowanceRaw.value === null) return null;
-    const token = (0, import_vue6.toValue)(options.token);
+    const token = (0, import_vue7.toValue)(options.token);
     const precision = (0, import_connect_appkit_core6.readDecimals)(decimals, token, token.decimals);
     return precision === void 0 ? null : (0, import_connect_core6.formatUnits)(allowanceRaw.value, precision);
   });
-  (0, import_vue6.onScopeDispose)(() => {
+  (0, import_vue7.onScopeDispose)(() => {
     disposed = true;
     generation++;
     allowanceGeneration++;
@@ -791,19 +838,19 @@ function useERC20Approve(options) {
 // src/useERC20TransferSimulation.ts
 var import_connect_appkit_core7 = require("@naculus/connect-appkit-core");
 var import_connect_core7 = require("@naculus/connect-core");
-var import_vue7 = require("vue");
+var import_vue8 = require("vue");
 function useERC20TransferSimulation(options) {
-  const transaction = (0, import_vue7.computed)(() => {
-    const token = (0, import_vue7.toValue)(options.token);
-    if (!(0, import_vue7.toValue)(options.connected) || !(0, import_vue7.toValue)(options.evmAccount))
+  const transaction = (0, import_vue8.computed)(() => {
+    const token = (0, import_vue8.toValue)(options.token);
+    if (!(0, import_vue8.toValue)(options.connected) || !(0, import_vue8.toValue)(options.evmAccount))
       return void 0;
     try {
       if (token.decimals === void 0) return void 0;
       return {
         to: token.address,
         data: (0, import_connect_appkit_core7.encodeErc20Transfer)(
-          (0, import_vue7.toValue)(options.to),
-          (0, import_connect_core7.parseUnits)((0, import_vue7.toValue)(options.amount), token.decimals)
+          (0, import_vue8.toValue)(options.to),
+          (0, import_connect_core7.parseUnits)((0, import_vue8.toValue)(options.amount), token.decimals)
         ),
         value: "0"
       };
@@ -811,10 +858,10 @@ function useERC20TransferSimulation(options) {
       return void 0;
     }
   });
-  const chainId = (0, import_vue7.computed)(() => {
-    const token = (0, import_vue7.toValue)(options.token);
+  const chainId = (0, import_vue8.computed)(() => {
+    const token = (0, import_vue8.toValue)(options.token);
     if (token.chainId !== void 0) return token.chainId;
-    const currentChain = (0, import_vue7.toValue)(options.currentChain);
+    const currentChain = (0, import_vue8.toValue)(options.currentChain);
     return currentChain ? (0, import_connect_appkit_core7.chainNumber)(currentChain) ?? void 0 : void 0;
   });
   const simulation = useTransactionSimulation(transaction, {
@@ -824,39 +871,39 @@ function useERC20TransferSimulation(options) {
     evmAccount: options.evmAccount
   });
   return {
-    result: (0, import_vue7.computed)(
+    result: (0, import_vue8.computed)(
       () => transaction.value ? simulation.result.value : void 0
     ),
-    isSimulating: (0, import_vue7.computed)(
+    isSimulating: (0, import_vue8.computed)(
       () => !!transaction.value && simulation.isSimulating.value
     ),
-    error: (0, import_vue7.computed)(() => transaction.value ? simulation.error.value : null),
+    error: (0, import_vue8.computed)(() => transaction.value ? simulation.error.value : null),
     reSimulate: simulation.simulate,
     reset: simulation.reset
   };
 }
 
 // src/useAccount.ts
-var import_vue8 = require("vue");
+var import_vue9 = require("vue");
 function useAccount(accounts, connected) {
   const parsed = useAccounts(accounts);
-  const isConnected = (0, import_vue8.computed)(() => (0, import_vue8.toValue)(connected));
-  const accountList = (0, import_vue8.computed)(() => (0, import_vue8.toValue)(accounts) ?? []);
+  const isConnected = (0, import_vue9.computed)(() => (0, import_vue9.toValue)(connected));
+  const accountList = (0, import_vue9.computed)(() => (0, import_vue9.toValue)(accounts) ?? []);
   return {
-    accounts: (0, import_vue8.computed)(
+    accounts: (0, import_vue9.computed)(
       () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
     ),
-    evmAccount: (0, import_vue8.computed)(
+    evmAccount: (0, import_vue9.computed)(
       () => isConnected.value ? parsed.evmAccount.value : null
     ),
-    primaryAccount: (0, import_vue8.computed)(() => accountList.value[0] ?? null),
+    primaryAccount: (0, import_vue9.computed)(() => accountList.value[0] ?? null),
     isConnected,
-    count: (0, import_vue8.computed)(() => accountList.value.length)
+    count: (0, import_vue9.computed)(() => accountList.value.length)
   };
 }
 
 // src/useSession.ts
-var import_vue9 = require("vue");
+var import_vue10 = require("vue");
 function readSession(manager) {
   const bundle = manager?.getActiveBundle();
   if (!bundle) {
@@ -875,9 +922,9 @@ function readSession(manager) {
   };
 }
 function useSession(manager) {
-  const snapshot = (0, import_vue9.shallowRef)(readSession((0, import_vue9.toValue)(manager)));
-  (0, import_vue9.watch)(
-    () => (0, import_vue9.toValue)(manager),
+  const snapshot = (0, import_vue10.shallowRef)(readSession((0, import_vue10.toValue)(manager)));
+  (0, import_vue10.watch)(
+    () => (0, import_vue10.toValue)(manager),
     (current, _previous, onCleanup) => {
       const update = () => {
         snapshot.value = readSession(current);
@@ -900,61 +947,17 @@ function useSession(manager) {
     { immediate: true }
   );
   return {
-    session: (0, import_vue9.computed)(() => snapshot.value.session),
-    chainSessions: (0, import_vue9.computed)(() => snapshot.value.chainSessions),
-    activeChainId: (0, import_vue9.computed)(() => snapshot.value.activeChainId),
-    isConnected: (0, import_vue9.computed)(() => snapshot.value.session !== null),
-    connectorId: (0, import_vue9.computed)(() => snapshot.value.connectorId)
+    session: (0, import_vue10.computed)(() => snapshot.value.session),
+    chainSessions: (0, import_vue10.computed)(() => snapshot.value.chainSessions),
+    activeChainId: (0, import_vue10.computed)(() => snapshot.value.activeChainId),
+    isConnected: (0, import_vue10.computed)(() => snapshot.value.session !== null),
+    connectorId: (0, import_vue10.computed)(() => snapshot.value.connectorId)
   };
 }
 
 // src/useConnect.ts
 var import_connect_core8 = require("@naculus/connect-core");
 var import_vue11 = require("vue");
-
-// src/internal/action-guard.ts
-var import_vue10 = require("vue");
-function useActionGuard() {
-  const busy = (0, import_vue10.shallowRef)(false);
-  const error = (0, import_vue10.shallowRef)(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++;
-  };
-  (0, import_vue10.onScopeDispose)(dispose);
-  return { busy, error, run, clearError, reset, dispose };
-}
-
-// src/useConnect.ts
 function useConnect(action, status) {
   const guard = useActionGuard();
   let inFlight = null;
@@ -1124,44 +1127,30 @@ function useSolanaTransaction(options) {
 // src/useSignInWithX.ts
 var import_vue17 = require("vue");
 function useSignInWithX(action) {
-  const isSigningIn = (0, import_vue17.shallowRef)(false);
+  const guard = useActionGuard();
   const result = (0, import_vue17.shallowRef)(null);
-  const error = (0, import_vue17.shallowRef)(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const signIn = async (options) => {
+  const signIn = (options) => {
     const invoke = (0, import_vue17.unref)(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;
   };
-  (0, import_vue17.onScopeDispose)(() => {
-    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
@@ -1322,6 +1311,10 @@ function useDelegationPolicy(options) {
     previewExecution: (callCount, atomicity) => (0, import_vue20.unref)(options.previewExecution)(callCount, atomicity),
     sponsorship: options.sponsorship,
     adapter: options.adapter,
+    signTypedData: options.signTypedData ? (typedData) => (0, import_vue20.unref)(
+      options.signTypedData
+    )(typedData) : void 0,
+    chainId: () => (0, import_vue20.toValue)(options.chainId) ?? null,
     delegation: () => (0, import_vue20.toValue)(options.delegation),
     encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
     storageAvailable: () => sessionKeys.storageAvailable,
@@ -1939,35 +1932,43 @@ var import_connect_appkit_core14 = require("@naculus/connect-appkit-core");
 var import_connect_core11 = require("@naculus/connect-core");
 var import_vue28 = require("vue");
 function useBalance(account, client, options = {}) {
+  const guard = useActionGuard();
   const balance = (0, import_vue28.shallowRef)(null);
   const isFetching = (0, import_vue28.shallowRef)(false);
-  const error = (0, import_vue28.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const refetch = async () => {
     const reader = (0, import_vue28.toValue)(client);
     const address = (0, import_connect_appkit_core14.bareEvmAddress)((0, import_vue28.toValue)(account));
-    const 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);
@@ -1986,11 +1987,7 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue28.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-    stopTimer();
-  });
+  (0, import_vue28.onScopeDispose)(stopTimer);
   return {
     balance,
     formatted: (0, import_vue28.computed)(
@@ -1998,7 +1995,7 @@ function useBalance(account, client, options = {}) {
     ),
     symbol: (0, import_vue28.computed)(() => (0, import_vue28.toValue)(options.symbol) ?? null),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
@@ -2007,45 +2004,64 @@ function useBalance(account, client, options = {}) {
 var import_connect_appkit_core15 = require("@naculus/connect-appkit-core");
 var import_vue29 = require("vue");
 function useRouteQuote(input, getQuotes, options = {}) {
+  const guard = useActionGuard();
   const quotes = (0, import_vue29.shallowRef)([]);
   const loading = (0, import_vue29.shallowRef)(false);
-  const error = (0, import_vue29.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const clearTimer = () => {
     if (timer) clearTimeout(timer);
     timer = null;
   };
-  const fetchQuotes = async () => {
-    const current = (0, import_vue29.toValue)(input);
-    const fn = (0, import_vue29.unref)(getQuotes);
-    const own = ++generation;
+  const requestable = (current) => {
     if (!(0, import_connect_appkit_core15.isQuotableInput)(current)) {
+      guard.invalidate();
+      loading.value = false;
       quotes.value = [];
-      return;
+      return null;
     }
+    const fn = (0, import_vue29.unref)(getQuotes);
+    if (!fn) {
+      guard.invalidate();
+      loading.value = false;
+      return null;
+    }
+    return fn;
+  };
+  const fetchQuotes = async () => {
+    const current = (0, import_vue29.toValue)(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(() => {
+    });
   };
   (0, import_vue29.watch)(
     [
@@ -2056,12 +2072,10 @@ function useRouteQuote(input, getQuotes, options = {}) {
       () => (0, import_vue29.toValue)(input).amount,
       () => (0, import_vue29.unref)(getQuotes)
     ],
-    ([fromChain, toChain, fromToken, , amount]) => {
+    () => {
       clearTimer();
-      if (!fromChain || !toChain || !fromToken || !amount) {
-        quotes.value = [];
-        return;
-      }
+      guard.invalidate();
+      if (!requestable((0, import_vue29.toValue)(input))) return;
       timer = setTimeout(() => {
         timer = null;
         void fetchQuotes();
@@ -2069,21 +2083,16 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue29.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-    clearTimer();
-  });
+  (0, import_vue29.onScopeDispose)(clearTimer);
   return {
     quotes,
     loading,
-    error,
+    error: guard.error,
     refresh: fetchQuotes,
     clear: () => {
       clearTimer();
-      generation++;
+      guard.reset();
       quotes.value = [];
-      error.value = null;
       loading.value = false;
     }
   };
@@ -2093,33 +2102,47 @@ function useRouteQuote(input, getQuotes, options = {}) {
 var import_connect_appkit_core16 = require("@naculus/connect-appkit-core");
 var import_vue30 = require("vue");
 function useCompareCosts(input, compareCosts) {
+  const guard = useActionGuard();
   const comparisons = (0, import_vue30.shallowRef)([]);
   const loading = (0, import_vue30.shallowRef)(false);
-  const error = (0, import_vue30.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   const fetchComparisons = async () => {
     const { operation, chains, options } = (0, import_vue30.toValue)(input);
     const fn = (0, import_vue30.unref)(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(() => {
+    });
   };
   (0, import_vue30.watch)(
     [() => (0, import_connect_appkit_core16.compareCostsKey)((0, import_vue30.toValue)(input)), () => (0, import_vue30.unref)(compareCosts)],
@@ -2128,11 +2151,12 @@ function useCompareCosts(input, compareCosts) {
     },
     { immediate: true }
   );
-  (0, import_vue30.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
-  return { comparisons, loading, error, refresh: fetchComparisons };
+  return {
+    comparisons,
+    loading,
+    error: guard.error,
+    refresh: fetchComparisons
+  };
 }
 
 // src/useExecuteRoute.ts
@@ -2207,12 +2231,10 @@ function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
   const manager = options.manager ?? new import_connect_core12.TokenListManager(config);
+  const guard = useActionGuard();
   const tokens = (0, import_vue32.shallowRef)([]);
   const isLoading = (0, import_vue32.shallowRef)(options.autoLoad !== false);
   const isLoaded = (0, import_vue32.shallowRef)(false);
-  const error = (0, import_vue32.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   const select = () => {
     const id = (0, import_vue32.toValue)(chainId);
     const numeric = id ? (0, import_connect_appkit_core18.eip155ChainIdToNumber)(id) : void 0;
@@ -2221,20 +2243,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(() => {
+    });
   };
   (0, import_vue32.watch)(
     () => (0, import_vue32.toValue)(chainId),
@@ -2243,15 +2269,11 @@ function useTokenList(chainId, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue32.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     tokens,
     isLoading,
     isLoaded,
-    error,
+    error: guard.error,
     refetch: () => run(() => manager.refresh())
   };
 }
@@ -2323,55 +2345,63 @@ function tokensKey(tokens) {
   return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
 }
 function useTokenBalance(account, client, tokens, options = {}) {
+  const guard = useActionGuard();
   const tokenBalances = (0, import_vue35.shallowRef)([]);
   const isFetching = (0, import_vue35.shallowRef)(false);
-  const error = (0, import_vue35.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   let timer = null;
   const refetch = async () => {
     const reader = (0, import_vue35.toValue)(client);
     const address = (0, import_connect_appkit_core21.bareEvmAddress)((0, import_vue35.toValue)(account));
     const list = (0, import_vue35.toValue)(tokens) ?? [];
-    const 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: import_connect_core14.ERC20_MIN_ABI,
-              functionName: "balanceOf",
-              args: [address]
-            });
-            const value = BigInt(raw);
-            return {
-              ...token,
-              balance: value.toString(),
-              formatted: (0, import_connect_core14.formatUnits)(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: import_connect_core14.ERC20_MIN_ABI,
+                  functionName: "balanceOf",
+                  args: [address]
+                });
+                const value = BigInt(raw);
+                return {
+                  ...token,
+                  balance: value.toString(),
+                  formatted: (0, import_connect_core14.formatUnits)(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);
@@ -2391,15 +2421,11 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue35.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-    stopTimer();
-  });
+  (0, import_vue35.onScopeDispose)(stopTimer);
   return {
     tokenBalances,
     isFetching,
-    error,
+    error: guard.error,
     refetch,
     getTokenBalance: (tokenAddress) => tokenBalances.value.find(
       (t) => t.address.toLowerCase() === tokenAddress.toLowerCase()
@@ -2504,35 +2530,42 @@ var import_connect_appkit_core23 = require("@naculus/connect-appkit-core");
 var import_connect_core16 = require("@naculus/connect-core");
 var import_vue37 = require("vue");
 function useDelegation(account, client, chainId) {
+  const guard = useActionGuard();
   const status = (0, import_vue37.shallowRef)(import_connect_core16.UNKNOWN_DELEGATION);
   const isFetching = (0, import_vue37.shallowRef)(false);
-  const error = (0, import_vue37.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
   const refetch = async () => {
-    const mine = ++generation;
     const reader = (0, import_vue37.toValue)(client);
     const address = (0, import_connect_appkit_core23.bareEvmAddress)((0, import_vue37.toValue)(account));
     status.value = import_connect_core16.UNKNOWN_DELEGATION;
-    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 = (0, import_connect_core16.readDelegation)(code ?? "0x");
-      }
-    } catch (cause) {
-      if (!disposed && mine === generation) {
-        status.value = import_connect_core16.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 = (0, import_connect_core16.readDelegation)(code ?? "0x");
+          });
+        } catch (cause) {
+          commit(() => {
+            status.value = import_connect_core16.UNKNOWN_DELEGATION;
+          });
+          throw cause;
+        }
+      },
+      "Code read failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
       }
-    } finally {
-      if (!disposed && mine === generation) isFetching.value = false;
-    }
+    ).catch(() => {
+    });
   };
   (0, import_vue37.watch)(
     [() => (0, import_vue37.toValue)(account), () => (0, import_vue37.toValue)(client), () => (0, import_vue37.toValue)(chainId)],
@@ -2541,72 +2574,108 @@ function useDelegation(account, client, chainId) {
     },
     { immediate: true, flush: "sync" }
   );
-  (0, import_vue37.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     delegated: (0, import_vue37.computed)(() => status.value.delegated),
     delegate: (0, import_vue37.computed)(() => status.value.delegate),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
 
-// src/name-lookup.ts
+// src/usePaymentFetch.ts
 var import_connect_appkit_core24 = require("@naculus/connect-appkit-core");
 var import_vue38 = require("vue");
+function usePaymentFetch(pay) {
+  const guard = useActionGuard();
+  const lastPayment = (0, import_vue38.shallowRef)(null);
+  let epoch = 0;
+  (0, import_vue38.onScopeDispose)(() => {
+    epoch++;
+  });
+  const payFetch = (input, init) => {
+    const invoke = (0, import_vue38.unref)(pay);
+    const own = epoch;
+    return guard.run(async () => {
+      const result = await invoke(input, init);
+      const payment = (0, import_connect_appkit_core24.describePayment)(input, result);
+      if (payment && own === epoch) lastPayment.value = payment;
+      return result;
+    }, "Paid request failed");
+  };
+  return {
+    payFetch,
+    isPending: guard.busy,
+    lastPayment,
+    error: guard.error,
+    reset: () => {
+      epoch++;
+      guard.reset();
+      lastPayment.value = null;
+    }
+  };
+}
+
+// src/name-lookup.ts
+var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
+var import_vue39 = require("vue");
 function useNameLookup(options) {
-  const data = (0, import_vue38.shallowRef)(null);
-  const loading = (0, import_vue38.shallowRef)(false);
-  const error = (0, import_vue38.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
+  const guard = useActionGuard();
+  const data = (0, import_vue39.shallowRef)(null);
+  const loading = (0, import_vue39.shallowRef)(false);
   const run = () => {
-    const input = (0, import_vue38.toValue)(options.input).trim();
-    const skip = (0, import_vue38.toValue)(options.skip) ?? false;
-    const scope = (0, import_vue38.toValue)(options.scope);
-    const config = (0, import_vue38.toValue)(options.resolverConfig);
-    const mine = ++generation;
+    const input = (0, import_vue39.toValue)(options.input).trim();
+    const skip = (0, import_vue39.toValue)(options.skip) ?? false;
+    const scope = (0, import_vue39.toValue)(options.scope);
+    const config = (0, import_vue39.toValue)(options.resolverConfig);
     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((0, import_connect_appkit_core24.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((0, import_connect_appkit_core25.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(() => {
     });
   };
-  (0, import_vue38.watch)(
+  (0, import_vue39.watch)(
     () => [
-      (0, import_vue38.toValue)(options.input),
-      (0, import_vue38.toValue)(options.skip),
-      (0, import_vue38.toValue)(options.scope),
-      (0, import_vue38.toValue)(options.resolverConfig)
+      (0, import_vue39.toValue)(options.input),
+      (0, import_vue39.toValue)(options.skip),
+      (0, import_vue39.toValue)(options.scope),
+      (0, import_vue39.toValue)(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
-  (0, import_vue38.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     data,
-    isLoading: (0, import_vue38.computed)(() => loading.value),
-    error,
+    isLoading: (0, import_vue39.computed)(() => loading.value),
+    error: guard.error,
     refetch: run
   };
 }
@@ -2633,21 +2702,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-var import_vue39 = require("vue");
+var import_vue40 = require("vue");
 function useSolanaAccount(accounts, connected) {
-  const isConnected = (0, import_vue39.computed)(() => (0, import_vue39.toValue)(connected));
-  const caip10 = (0, import_vue39.computed)(
-    () => isConnected.value ? ((0, import_vue39.toValue)(accounts) ?? []).find(
+  const isConnected = (0, import_vue40.computed)(() => (0, import_vue40.toValue)(connected));
+  const caip10 = (0, import_vue40.computed)(
+    () => isConnected.value ? ((0, import_vue40.toValue)(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
-  const parts = (0, import_vue39.computed)(() => caip10.value?.split(":") ?? []);
+  const parts = (0, import_vue40.computed)(() => caip10.value?.split(":") ?? []);
   return {
-    address: (0, import_vue39.computed)(
+    address: (0, import_vue40.computed)(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: (0, import_vue39.computed)(
+    chainId: (0, import_vue40.computed)(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -2655,35 +2724,35 @@ function useSolanaAccount(accounts, connected) {
 }
 
 // src/useChain.ts
-var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
-var import_vue40 = require("vue");
+var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
+var import_vue41 = require("vue");
 function useChain(chains, chainId) {
-  const list = (0, import_vue40.computed)(() => (0, import_vue40.toValue)(chains) ?? []);
-  const id = (0, import_vue40.computed)(() => (0, import_vue40.toValue)(chainId) ?? null);
-  const currentChain = (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.resolveChain)(list.value, id.value));
+  const list = (0, import_vue41.computed)(() => (0, import_vue41.toValue)(chains) ?? []);
+  const id = (0, import_vue41.computed)(() => (0, import_vue41.toValue)(chainId) ?? null);
+  const currentChain = (0, import_vue41.computed)(() => (0, import_connect_appkit_core26.resolveChain)(list.value, id.value));
   return {
     currentChain,
-    chainInfo: (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.describeChain)(list.value, id.value)),
-    availableChains: (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.chainsForNamespace)(list.value, id.value)),
-    currentChainNumber: (0, import_vue40.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core25.chainNumber)(currentChain.value) : null
+    chainInfo: (0, import_vue41.computed)(() => (0, import_connect_appkit_core26.describeChain)(list.value, id.value)),
+    availableChains: (0, import_vue41.computed)(() => (0, import_connect_appkit_core26.chainsForNamespace)(list.value, id.value)),
+    currentChainNumber: (0, import_vue41.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core26.chainNumber)(currentChain.value) : null
     ),
-    namespace: (0, import_vue40.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core25.chainNamespace)(currentChain.value) : null
+    namespace: (0, import_vue41.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core26.chainNamespace)(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-var import_vue41 = require("vue");
+var import_vue42 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue41.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue42.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue41.onScopeDispose)(unsubscribe);
+  (0, import_vue42.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue41.readonly)(request),
+    request: (0, import_vue42.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -2692,54 +2761,61 @@ function usePassphraseGate(gate) {
 
 // src/useSolanaBalance.ts
 var import_connect_core17 = require("@naculus/connect-core");
-var import_vue42 = require("vue");
+var import_vue43 = require("vue");
 function useSolanaBalance(address, rpcUrl) {
-  const balance = (0, import_vue42.shallowRef)(null);
-  const isFetching = (0, import_vue42.ref)(false);
-  const error = (0, import_vue42.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
+  const guard = useActionGuard();
+  const balance = (0, import_vue43.shallowRef)(null);
+  const isFetching = (0, import_vue43.ref)(false);
   const refetch = async () => {
-    const addr = (0, import_vue42.toValue)(address);
-    const url = (0, import_vue42.toValue)(rpcUrl);
+    const addr = (0, import_vue43.toValue)(address);
+    const url = (0, import_vue43.toValue)(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 (0, import_connect_core17.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 (0, import_connect_core17.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(() => {
+    });
   };
-  (0, import_vue42.watchEffect)(() => {
-    (0, import_vue42.toValue)(address);
-    (0, import_vue42.toValue)(rpcUrl);
+  (0, import_vue43.watchEffect)(() => {
+    (0, import_vue43.toValue)(address);
+    (0, import_vue43.toValue)(rpcUrl);
     void refetch();
   });
-  (0, import_vue42.onScopeDispose)(() => {
-    disposed = true;
-  });
-  return { balance, isFetching, error, refetch };
+  return { balance, isFetching, error: guard.error, refetch };
 }
 
 // src/useLastTx.ts
-var import_vue43 = require("vue");
+var import_vue44 = require("vue");
 function useLastTx(monitor) {
-  const lastTx = (0, import_vue43.shallowRef)(null);
-  const lastConfirmedTx = (0, import_vue43.shallowRef)(null);
-  const lastFailedTx = (0, import_vue43.shallowRef)(null);
-  (0, import_vue43.watch)(
-    () => (0, import_vue43.toValue)(monitor),
+  const lastTx = (0, import_vue44.shallowRef)(null);
+  const lastConfirmedTx = (0, import_vue44.shallowRef)(null);
+  const lastFailedTx = (0, import_vue44.shallowRef)(null);
+  (0, import_vue44.watch)(
+    () => (0, import_vue44.toValue)(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -2777,38 +2853,42 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-var import_vue44 = require("vue");
+var import_vue45 = require("vue");
 function useTxHistory(address, chainId, monitor) {
-  const entries = (0, import_vue44.shallowRef)([]);
-  const isLoading = (0, import_vue44.shallowRef)(false);
-  const error = (0, import_vue44.shallowRef)(null);
-  let generation = 0;
+  const guard = useActionGuard();
+  const entries = (0, import_vue45.shallowRef)([]);
+  const isLoading = (0, import_vue45.shallowRef)(false);
   const refresh = async () => {
-    const mine = ++generation;
-    const activeMonitor = (0, import_vue44.toValue)(monitor);
+    const activeMonitor = (0, import_vue45.toValue)(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(
-        (0, import_vue44.toValue)(address) ?? void 0,
-        (0, import_vue44.toValue)(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(
+          (0, import_vue45.toValue)(address) ?? void 0,
+          (0, import_vue45.toValue)(chainId) ?? void 0
+        );
+        commit(() => {
+          entries.value = result;
+        });
+      },
+      "Failed to load transaction history",
+      void 0,
+      {
+        onSettled: () => {
+          isLoading.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
-  (0, import_vue44.watch)(
-    [() => (0, import_vue44.toValue)(monitor), () => (0, import_vue44.toValue)(address), () => (0, import_vue44.toValue)(chainId)],
+  (0, import_vue45.watch)(
+    [() => (0, import_vue45.toValue)(monitor), () => (0, import_vue45.toValue)(address), () => (0, import_vue45.toValue)(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -2826,9 +2906,9 @@ function useTxHistory(address, chainId, monitor) {
   return {
     entries,
     isLoading,
-    error,
+    error: guard.error,
     refresh,
-    summary: (0, import_vue44.computed)(() => ({
+    summary: (0, import_vue45.computed)(() => ({
       pending: entries.value.filter((item) => item.status === "pending").length,
       confirmed: entries.value.filter((item) => item.status === "confirmed").length,
       failed: entries.value.filter((item) => item.status === "failed").length
@@ -2837,17 +2917,17 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-var import_vue45 = require("vue");
+var import_vue46 = require("vue");
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = (0, import_vue45.shallowRef)(null);
-  const isLoading = (0, import_vue45.shallowRef)(false);
-  const isWatching = (0, import_vue45.shallowRef)(false);
-  const error = (0, import_vue45.shallowRef)(null);
+  const entry = (0, import_vue46.shallowRef)(null);
+  const isLoading = (0, import_vue46.shallowRef)(false);
+  const isWatching = (0, import_vue46.shallowRef)(false);
+  const error = (0, import_vue46.shallowRef)(null);
   let generation = 0;
   const refresh = async () => {
-    const activeMonitor = (0, import_vue45.toValue)(monitor);
-    const activeHash = (0, import_vue45.toValue)(hash);
-    const activeChainId = (0, import_vue45.toValue)(chainId);
+    const activeMonitor = (0, import_vue46.toValue)(monitor);
+    const activeHash = (0, import_vue46.toValue)(hash);
+    const activeChainId = (0, import_vue46.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     isLoading.value = true;
     error.value = null;
@@ -2865,15 +2945,15 @@ function useTxMonitor(hash, chainId, monitor) {
     }
   };
   const stopWatching = () => {
-    const activeMonitor = (0, import_vue45.toValue)(monitor);
-    const activeHash = (0, import_vue45.toValue)(hash);
-    const activeChainId = (0, import_vue45.toValue)(chainId);
+    const activeMonitor = (0, import_vue46.toValue)(monitor);
+    const activeHash = (0, import_vue46.toValue)(hash);
+    const activeChainId = (0, import_vue46.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  (0, import_vue45.watch)(
-    [() => (0, import_vue45.toValue)(monitor), () => (0, import_vue45.toValue)(hash), () => (0, import_vue45.toValue)(chainId)],
+  (0, import_vue46.watch)(
+    [() => (0, import_vue46.toValue)(monitor), () => (0, import_vue46.toValue)(hash), () => (0, import_vue46.toValue)(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
       if (!activeMonitor || !activeHash || !activeChainId) {
@@ -2913,7 +2993,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: (0, import_vue45.computed)(() => entry.value?.status ?? "idle"),
+    status: (0, import_vue46.computed)(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -2923,71 +3003,80 @@ function useTxMonitor(hash, chainId, monitor) {
 }
 
 // src/useCapabilities.ts
-var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
-var import_vue46 = require("vue");
+var import_connect_appkit_core27 = require("@naculus/connect-appkit-core");
+var import_vue47 = require("vue");
 function useCapabilities(client, session, chainId) {
-  const capabilities = (0, import_vue46.shallowRef)(
+  const guard = useActionGuard();
+  const capabilities = (0, import_vue47.shallowRef)(
     null
   );
-  const isFetching = (0, import_vue46.shallowRef)(false);
-  const error = (0, import_vue46.shallowRef)(null);
-  let generation = 0;
+  const isFetching = (0, import_vue47.shallowRef)(false);
   const refetch = async () => {
-    const mine = ++generation;
-    const activeClient = (0, import_vue46.toValue)(client);
-    const activeSession = (0, import_vue46.toValue)(session);
+    const activeClient = (0, import_vue47.toValue)(client);
+    const activeSession = (0, import_vue47.toValue)(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 = (0, import_connect_appkit_core26.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 = (0, import_connect_appkit_core27.normalizeCapabilities)(raw);
+          });
+        } catch (err) {
+          commit(() => {
+            capabilities.value = null;
+          });
+          throw err;
+        }
+      },
+      "Capability query failed",
+      void 0,
+      {
+        onSettled: () => {
+          isFetching.value = false;
+        }
+      }
+    ).catch(() => {
+    });
   };
-  (0, import_vue46.watchEffect)(() => {
-    void (0, import_vue46.toValue)(client);
-    void (0, import_vue46.toValue)(session);
+  (0, import_vue47.watchEffect)(() => {
+    void (0, import_vue47.toValue)(client);
+    void (0, import_vue47.toValue)(session);
     void refetch();
   });
   return {
     capabilities,
-    current: (0, import_vue46.computed)(
-      () => (0, import_connect_appkit_core26.selectChainCapabilities)(capabilities.value, (0, import_vue46.toValue)(chainId))
+    current: (0, import_vue47.computed)(
+      () => (0, import_connect_appkit_core27.selectChainCapabilities)(capabilities.value, (0, import_vue47.toValue)(chainId))
     ),
-    atomic: (0, import_vue46.computed)(
-      () => (0, import_connect_appkit_core26.atomicSupportFor)(capabilities.value, (0, import_vue46.toValue)(chainId))
+    atomic: (0, import_vue47.computed)(
+      () => (0, import_connect_appkit_core27.atomicSupportFor)(capabilities.value, (0, import_vue47.toValue)(chainId))
     ),
     isFetching,
-    error,
+    error: guard.error,
     refetch
   };
 }
 
 // src/useSolanaRoles.ts
-var import_connect_appkit_core27 = require("@naculus/connect-appkit-core");
-var import_vue47 = require("vue");
+var import_connect_appkit_core28 = require("@naculus/connect-appkit-core");
+var import_vue48 = require("vue");
 function useSolanaRoles(connector, session) {
-  const state = (0, import_vue47.computed)(
-    () => (0, import_connect_appkit_core27.readSolanaRoles)((0, import_vue47.toValue)(connector), (0, import_vue47.toValue)(session))
+  const state = (0, import_vue48.computed)(
+    () => (0, import_connect_appkit_core28.readSolanaRoles)((0, import_vue48.toValue)(connector), (0, import_vue48.toValue)(session))
   );
   return {
-    roles: (0, import_vue47.computed)(() => state.value.roles),
-    absence: (0, import_vue47.computed)(() => state.value.absence),
-    identity: (0, import_vue47.computed)(() => state.value.roles?.identity ?? null),
-    signer: (0, import_vue47.computed)(() => state.value.roles?.signer ?? null),
-    payer: (0, import_vue47.computed)(() => state.value.roles?.payer ?? null)
+    roles: (0, import_vue48.computed)(() => state.value.roles),
+    absence: (0, import_vue48.computed)(() => state.value.absence),
+    identity: (0, import_vue48.computed)(() => state.value.roles?.identity ?? null),
+    signer: (0, import_vue48.computed)(() => state.value.roles?.signer ?? null),
+    payer: (0, import_vue48.computed)(() => state.value.roles?.payer ?? null)
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3042,6 +3131,7 @@ function useSolanaRoles(connector, session) {
   useLookupAddress,
   useNotification,
   usePassphraseGate,
+  usePaymentFetch,
   useResolveName,
   useRevokeSession,
   useRouteQuote,