@naculus/connect-appkit-vue 0.8.1 → 0.10.0

package/dist/index.js

@@ -1032,12 +1032,32 @@ function useSwitchChain(action, chainId) {
   };
 }
 
+// src/useX402Signer.ts
+import {
+  createX402WalletSigner
+} from "@naculus/connect-appkit-core";
+import { computed as computed9, toValue as toValue11, unref as unref10 } from "vue";
+function useX402Signer(session, provider, switchChain, chainId) {
+  const resolved = computed9(() => {
+    toValue11(chainId);
+    return createX402WalletSigner(
+      toValue11(session),
+      toValue11(provider),
+      unref10(switchChain)
+    );
+  });
+  return {
+    signer: computed9(() => resolved.value.signer),
+    reason: computed9(() => resolved.value.reason)
+  };
+}
+
 // src/useSignMessage.ts
-import { unref as unref10 } from "vue";
+import { unref as unref11 } from "vue";
 function useSignMessage(action) {
   const guard = useActionGuard();
   const signMessage = (message) => {
-    const invoke = unref10(action);
+    const invoke = unref11(action);
     return guard.run(() => invoke(message), "Signing failed");
   };
   return {
@@ -1049,12 +1069,12 @@ function useSignMessage(action) {
 }
 
 // src/useSendTransaction.ts
-import { computed as computed9, shallowRef as shallowRef9, unref as unref11 } from "vue";
+import { computed as computed10, shallowRef as shallowRef9, unref as unref12 } from "vue";
 function useSendTransaction(action) {
   const guard = useActionGuard();
   const status = shallowRef9("idle");
   const sendTransaction = (transaction) => {
-    const invoke = unref11(action);
+    const invoke = unref12(action);
     status.value = "awaiting_approval";
     return guard.run(async (commit) => {
       const hash = await invoke(transaction);
@@ -1076,12 +1096,12 @@ function useSendTransaction(action) {
     status,
     error: guard.error,
     reset,
-    isSending: computed9(() => status.value === "awaiting_approval")
+    isSending: computed10(() => status.value === "awaiting_approval")
   };
 }
 
 // src/useSolanaTransaction.ts
-import { shallowRef as shallowRef10, unref as unref12 } from "vue";
+import { shallowRef as shallowRef10, unref as unref13 } from "vue";
 function useSolanaTransaction(options) {
   const guard = useActionGuard();
   const isSigning = shallowRef10(false);
@@ -1089,7 +1109,7 @@ function useSolanaTransaction(options) {
   let signing = 0;
   let sending = 0;
   const signTransaction = (transaction) => {
-    const invoke = unref12(options.signTransaction);
+    const invoke = unref13(options.signTransaction);
     signing++;
     isSigning.value = true;
     return guard.run(() => invoke(transaction), "Signing failed").finally(() => {
@@ -1098,7 +1118,7 @@ function useSolanaTransaction(options) {
     });
   };
   const sendTransaction = (transaction) => {
-    const invoke = unref12(options.sendTransaction);
+    const invoke = unref13(options.sendTransaction);
     sending++;
     isSending.value = true;
     return guard.run(() => invoke(transaction), "Send failed").finally(() => {
@@ -1106,7 +1126,7 @@ function useSolanaTransaction(options) {
       isSending.value = sending > 0;
     });
   };
-  const getStatus = (signature) => unref12(options.getStatus)(signature);
+  const getStatus = (signature) => unref13(options.getStatus)(signature);
   return {
     signTransaction,
     sendTransaction,
@@ -1119,12 +1139,12 @@ function useSolanaTransaction(options) {
 }
 
 // src/useSignInWithX.ts
-import { shallowRef as shallowRef11, unref as unref13 } from "vue";
+import { shallowRef as shallowRef11, unref as unref14 } from "vue";
 function useSignInWithX(action) {
   const guard = useActionGuard();
   const result = shallowRef11(null);
   const signIn = (options) => {
-    const invoke = unref13(action);
+    const invoke = unref14(action);
     return guard.run(async (commit) => {
       const next = await invoke(options);
       commit(() => {
@@ -1153,24 +1173,24 @@ function useSignInWithEthereum(action) {
 }
 
 // src/useExecuteCalls.ts
-import { computed as computed10, toValue as toValue11, unref as unref14 } from "vue";
+import { computed as computed11, toValue as toValue12, unref as unref15 } from "vue";
 function useExecuteCalls(options) {
   const guard = useActionGuard();
-  const preview = (callCount, atomicity) => unref14(options.preview)(callCount, atomicity);
+  const preview = (callCount, atomicity) => unref15(options.preview)(callCount, atomicity);
   const execute = (calls, atomicity) => {
-    const invoke = unref14(options.execute);
+    const invoke = unref15(options.execute);
     return guard.run(() => invoke(calls, atomicity), "Execution failed");
   };
   const reset = () => {
     guard.reset();
-    unref14(options.reset)();
+    unref15(options.reset)();
   };
   return {
     preview,
     execute,
     isExecuting: guard.busy,
     error: guard.error,
-    lastRoute: computed10(() => toValue11(options.lastRoute)),
+    lastRoute: computed11(() => toValue12(options.lastRoute)),
     reset
   };
 }
@@ -1183,17 +1203,17 @@ import {
   isVerifiablePolicy
 } from "@naculus/connect-appkit-core";
 import {
-  computed as computed12,
+  computed as computed13,
   onScopeDispose as onScopeDispose8,
   shallowRef as shallowRef13,
-  toValue as toValue13,
-  unref as unref15,
+  toValue as toValue14,
+  unref as unref16,
   watch as watch7
 } from "vue";
 
 // src/useSessionKeys.ts
 import { getSharedSessionKeyManager } from "@naculus/connect-appkit-core";
-import { computed as computed11, onScopeDispose as onScopeDispose7, shallowRef as shallowRef12, toValue as toValue12, watch as watch6 } from "vue";
+import { computed as computed12, onScopeDispose as onScopeDispose7, shallowRef as shallowRef12, toValue as toValue13, watch as watch6 } from "vue";
 function resolveManager(config, options) {
   return options.manager ?? getSharedSessionKeyManager(config);
 }
@@ -1206,7 +1226,7 @@ function useSessionKeys(connected, config, options = {}) {
   let disposed = false;
   const refresh = async () => {
     const own = ++generation;
-    if (!toValue12(connected)) {
+    if (!toValue13(connected)) {
       sessions.value = [];
       return;
     }
@@ -1224,7 +1244,7 @@ function useSessionKeys(connected, config, options = {}) {
     }
   };
   watch6(
-    () => toValue12(connected),
+    () => toValue13(connected),
     () => {
       void refresh();
     },
@@ -1236,7 +1256,7 @@ function useSessionKeys(connected, config, options = {}) {
   });
   return {
     sessions,
-    activeSessions: computed11(
+    activeSessions: computed12(
       () => sessions.value.filter((s) => s.status === "active")
     ),
     loading,
@@ -1311,17 +1331,17 @@ function useDelegationPolicy(options) {
   const flow = createDelegationPolicyFlow({
     manager,
     origin,
-    signer: () => bareEvmAddress2(toValue13(options.account)),
-    signMessage: (message) => unref15(options.signMessage)(message),
-    verifySignature: (input) => unref15(options.verifySignature)(input),
-    previewExecution: (callCount, atomicity) => unref15(options.previewExecution)(callCount, atomicity),
+    signer: () => bareEvmAddress2(toValue14(options.account)),
+    signMessage: (message) => unref16(options.signMessage)(message),
+    verifySignature: (input) => unref16(options.verifySignature)(input),
+    previewExecution: (callCount, atomicity) => unref16(options.previewExecution)(callCount, atomicity),
     sponsorship: options.sponsorship,
     adapter: options.adapter,
-    signTypedData: options.signTypedData ? (typedData) => unref15(
+    signTypedData: options.signTypedData ? (typedData) => unref16(
       options.signTypedData
     )(typedData) : void 0,
-    chainId: () => toValue13(options.chainId) ?? null,
-    delegation: () => toValue13(options.delegation),
+    chainId: () => toValue14(options.chainId) ?? null,
+    delegation: () => toValue14(options.delegation),
     encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
     storageAvailable: () => sessionKeys.storageAvailable,
     refresh: sessionKeys.refresh
@@ -1362,15 +1382,15 @@ function useDelegationPolicy(options) {
   });
   return {
     policies: sessionKeys.sessions,
-    activePolicies: computed12(
+    activePolicies: computed13(
       () => sessionKeys.activeSessions.value.filter(
         (p) => verifiedIds.value.has(p.id)
       )
     ),
     storageAvailable: sessionKeys.storageAvailable,
-    loading: computed12(() => sessionKeys.loading.value || isVerifying.value),
+    loading: computed13(() => sessionKeys.loading.value || isVerifying.value),
     isBusy: guard.busy,
-    error: computed12(
+    error: computed13(
       () => guard.error.value ?? verifyError.value ?? sessionKeys.error.value
     ),
     createPolicy: (scope) => guard.run(() => flow.createPolicy(scope), "Policy creation failed"),
@@ -1398,11 +1418,11 @@ import {
 } from "@naculus/connect-appkit-core";
 import { WalletError as WalletError5 } from "@naculus/connect-core";
 import {
-  computed as computed13,
+  computed as computed14,
   onScopeDispose as onScopeDispose9,
   shallowRef as shallowRef14,
-  toValue as toValue14,
-  unref as unref16,
+  toValue as toValue15,
+  unref as unref17,
   watch as watch8
 } from "vue";
 function useSmartAccount(options) {
@@ -1414,17 +1434,17 @@ function useSmartAccount(options) {
   let generation = 0;
   let inFlight = false;
   let disposed = false;
-  const chainId = computed13(
+  const chainId = computed14(
     () => resolveEvmChainId(
-      toValue14(options.chainId),
-      toValue14(options.connectedChainId)
+      toValue15(options.chainId),
+      toValue15(options.connectedChainId)
     )
   );
   watch8(
     [
-      () => toValue14(options.manager),
-      () => toValue14(options.rpcUrl),
-      () => toValue14(options.bundlerUrl),
+      () => toValue15(options.manager),
+      () => toValue15(options.rpcUrl),
+      () => toValue15(options.bundlerUrl),
       () => chainId.value
     ],
     ([supplied, rpcUrl, bundlerUrl, chain]) => {
@@ -1449,8 +1469,8 @@ function useSmartAccount(options) {
     },
     { immediate: true }
   );
-  const config = computed13(() => {
-    const owner = bareEvmAddress3(toValue14(options.account));
+  const config = computed14(() => {
+    const owner = bareEvmAddress3(toValue15(options.account));
     const chain = chainId.value;
     if (!owner || !chain || !managerRef.value) return null;
     return buildSmartAccountConfig(owner, chain, {
@@ -1500,7 +1520,7 @@ function useSmartAccount(options) {
     return info;
   }, "Failed to create smart account");
   const deployWallet = () => operate(async (manager, cfg, commit) => {
-    const send = unref16(options.sendTransaction);
+    const send = unref17(options.sendTransaction);
     if (!send) {
       throw new WalletError5(
         "wallet_unavailable",
@@ -1554,7 +1574,7 @@ import {
   resolveUserOpChain
 } from "@naculus/connect-appkit-core";
 import { WalletError as WalletError6 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose10, shallowRef as shallowRef15, toValue as toValue15, unref as unref17 } from "vue";
+import { onScopeDispose as onScopeDispose10, shallowRef as shallowRef15, toValue as toValue16, unref as unref18 } from "vue";
 function useSendUserOperation(options) {
   const userOpHash = shallowRef15(null);
   const receipt = shallowRef15(null);
@@ -1569,8 +1589,8 @@ function useSendUserOperation(options) {
     return null;
   };
   const sendUserOp = async (calls, opts) => {
-    const rpcUrl = toValue15(options.rpcUrl);
-    const bundlerUrl = toValue15(options.bundlerUrl);
+    const rpcUrl = toValue16(options.rpcUrl);
+    const bundlerUrl = toValue16(options.bundlerUrl);
     if (!rpcUrl) return fail(new Error("RPC URL not configured"));
     if (!bundlerUrl) return fail(new Error("Bundler URL not configured"));
     if (!calls.length) return fail(new Error("At least one call is required"));
@@ -1578,7 +1598,7 @@ function useSendUserOperation(options) {
       return fail(new Error("A UserOperation is already in progress"));
     }
     const owner = bareEvmAddress4(
-      toValue15(options.owner) ?? toValue15(options.account)
+      toValue16(options.owner) ?? toValue16(options.account)
     );
     if (!owner) {
       return fail(
@@ -1588,13 +1608,13 @@ function useSendUserOperation(options) {
     let targetChainId;
     try {
       targetChainId = resolveUserOpChain(
-        toValue15(options.chainId),
-        toValue15(options.connectedChainId)
+        toValue16(options.chainId),
+        toValue16(options.connectedChainId)
       );
     } catch (chainError) {
       return fail(chainError);
     }
-    const signer = unref17(options.signer);
+    const signer = unref18(options.signer);
     const own = ++requestId;
     inFlight = true;
     isPending.value = true;
@@ -1665,7 +1685,7 @@ import {
   fetchUserOperationReceipt,
   InvalidUserOperationReceiptError
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef16, toValue as toValue16 } from "vue";
+import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef16, toValue as toValue17 } from "vue";
 function useUserOpStatus(options) {
   const status = shallowRef16("idle");
   const receipt = shallowRef16(null);
@@ -1694,7 +1714,7 @@ function useUserOpStatus(options) {
     clearTimers();
   };
   const poll = async (hash, own) => {
-    const bundlerUrl = toValue16(options.bundlerUrl);
+    const bundlerUrl = toValue17(options.bundlerUrl);
     if (!bundlerUrl || own !== generation) return;
     const attempt = ++attempts.value;
     const abort = new AbortController();
@@ -1751,7 +1771,7 @@ function useUserOpStatus(options) {
     error.value = null;
     attempts.value = 0;
     elapsedMs.value = 0;
-    if (!toValue16(options.bundlerUrl)) {
+    if (!toValue17(options.bundlerUrl)) {
       finish("not_found", new Error("Bundler URL not configured"));
       return;
     }
@@ -1795,7 +1815,7 @@ function useUserOpStatus(options) {
 }
 
 // src/useSendCalls.ts
-import { computed as computed14, onScopeDispose as onScopeDispose12, shallowRef as shallowRef17, toValue as toValue17, unref as unref18 } from "vue";
+import { computed as computed15, onScopeDispose as onScopeDispose12, shallowRef as shallowRef17, toValue as toValue18, unref as unref19 } from "vue";
 function useSendCalls(options) {
   const status = shallowRef17("idle");
   const error = shallowRef17(null);
@@ -1805,7 +1825,7 @@ function useSendCalls(options) {
   let statusGeneration = 0;
   let disposed = false;
   const sendCalls = async (calls, input) => {
-    const invoke = unref18(options.sendCalls);
+    const invoke = unref19(options.sendCalls);
     const own = ++sendGeneration;
     status.value = "awaiting_approval";
     error.value = null;
@@ -1827,13 +1847,13 @@ function useSendCalls(options) {
     }
   };
   const getCallsStatus = async (hash) => {
-    const invoke = unref18(options.getCallsStatus);
+    const invoke = unref19(options.getCallsStatus);
     const own = ++statusGeneration;
     const result = await invoke(hash);
     if (!disposed && own === statusGeneration) callsStatus.value = result;
     return result;
   };
-  const showCallsStatus = (hash) => unref18(options.showCallsStatus)(hash);
+  const showCallsStatus = (hash) => unref19(options.showCallsStatus)(hash);
   const reset = () => {
     sendGeneration++;
     statusGeneration++;
@@ -1855,38 +1875,38 @@ function useSendCalls(options) {
     error,
     batchHash,
     callsStatus,
-    execution: computed14(() => toValue17(options.execution) ?? null),
-    isSending: computed14(() => status.value === "awaiting_approval"),
+    execution: computed15(() => toValue18(options.execution) ?? null),
+    isSending: computed15(() => status.value === "awaiting_approval"),
     reset
   };
 }
 
 // src/useEmbeddedWallet.ts
-import { computed as computed15, toValue as toValue18, unref as unref19 } from "vue";
+import { computed as computed16, toValue as toValue19, unref as unref20 } from "vue";
 function useEmbeddedWallet(options) {
   const guard = useActionGuard();
   const run = (action) => guard.run(action, "Embedded wallet action failed");
-  const wallet = computed15(() => toValue18(options.wallet));
+  const wallet = computed16(() => toValue19(options.wallet));
   return {
     wallet,
-    hasWallet: computed15(() => wallet.value !== null),
-    address: computed15(() => wallet.value?.address ?? null),
-    accounts: computed15(() => wallet.value?.accounts ?? []),
-    activeNamespace: computed15(() => wallet.value?.activeNamespace ?? null),
-    backupPending: computed15(() => toValue18(options.backupPending)),
-    storageSecurityLevel: computed15(() => toValue18(options.storageSecurityLevel)),
-    securityReport: computed15(() => toValue18(options.securityReport)),
-    connectEmbedded: () => run(() => unref19(options.connectEmbedded)()),
-    restoreWallet: () => run(() => unref19(options.restoreWallet)()),
-    generateWallet: () => run(() => unref19(options.generateWallet)()),
-    importFromMnemonic: (value) => run(() => unref19(options.importFromMnemonic)(value)),
-    importFromPrivateKey: (value) => run(() => unref19(options.importFromPrivateKey)(value)),
-    wipe: () => run(() => unref19(options.wipe)()),
-    setActiveNamespace: (value) => unref19(options.setActiveNamespace)(value),
-    backfillAccounts: () => run(() => unref19(options.backfillAccounts)()),
-    getSeedPhrase: () => unref19(options.getSeedPhrase)(),
-    getPrivateKey: () => unref19(options.getPrivateKey)(),
-    confirmBackup: () => unref19(options.confirmBackup)(),
+    hasWallet: computed16(() => wallet.value !== null),
+    address: computed16(() => wallet.value?.address ?? null),
+    accounts: computed16(() => wallet.value?.accounts ?? []),
+    activeNamespace: computed16(() => wallet.value?.activeNamespace ?? null),
+    backupPending: computed16(() => toValue19(options.backupPending)),
+    storageSecurityLevel: computed16(() => toValue19(options.storageSecurityLevel)),
+    securityReport: computed16(() => toValue19(options.securityReport)),
+    connectEmbedded: () => run(() => unref20(options.connectEmbedded)()),
+    restoreWallet: () => run(() => unref20(options.restoreWallet)()),
+    generateWallet: () => run(() => unref20(options.generateWallet)()),
+    importFromMnemonic: (value) => run(() => unref20(options.importFromMnemonic)(value)),
+    importFromPrivateKey: (value) => run(() => unref20(options.importFromPrivateKey)(value)),
+    wipe: () => run(() => unref20(options.wipe)()),
+    setActiveNamespace: (value) => unref20(options.setActiveNamespace)(value),
+    backfillAccounts: () => run(() => unref20(options.backfillAccounts)()),
+    getSeedPhrase: () => unref20(options.getSeedPhrase)(),
+    getPrivateKey: () => unref20(options.getPrivateKey)(),
+    confirmBackup: () => unref20(options.confirmBackup)(),
     isBusy: guard.busy,
     error: guard.error,
     clearError: guard.clearError
@@ -1905,43 +1925,43 @@ function useSIWxLogin(action) {
 }
 
 // src/useSIWxSession.ts
-import { computed as computed16, toValue as toValue19, unref as unref20 } from "vue";
+import { computed as computed17, toValue as toValue20, unref as unref21 } from "vue";
 function useSIWxSession(options) {
   const guard = useActionGuard();
   return {
-    session: computed16(() => toValue19(options.session)),
-    isAuthenticated: computed16(
-      () => toValue19(options.session) !== null && !toValue19(options.isExpired)
+    session: computed17(() => toValue20(options.session)),
+    isAuthenticated: computed17(
+      () => toValue20(options.session) !== null && !toValue20(options.isExpired)
     ),
-    isRestoring: computed16(() => toValue19(options.isRestoring)),
+    isRestoring: computed17(() => toValue20(options.isRestoring)),
     isSigningIn: guard.busy,
-    isExpired: computed16(() => toValue19(options.isExpired)),
-    timeUntilExpiry: computed16(() => toValue19(options.timeUntilExpiry)),
-    signIn: (input) => guard.run(() => unref20(options.signIn)(input), "SIWX sign-in failed"),
+    isExpired: computed17(() => toValue20(options.isExpired)),
+    timeUntilExpiry: computed17(() => toValue20(options.timeUntilExpiry)),
+    signIn: (input) => guard.run(() => unref21(options.signIn)(input), "SIWX sign-in failed"),
     signOut: async () => {
-      await unref20(options.signOut)();
+      await unref21(options.signOut)();
       guard.clearError();
     },
-    refresh: () => guard.run(() => unref20(options.refresh)(), "Session refresh failed"),
+    refresh: () => guard.run(() => unref21(options.refresh)(), "Session refresh failed"),
     error: guard.error,
     clearError: guard.clearError
   };
 }
 
 // src/useSiwxAuthSession.ts
-import { computed as computed17, toValue as toValue20, unref as unref21 } from "vue";
+import { computed as computed18, toValue as toValue21, unref as unref22 } from "vue";
 function useSiwxAuthSession(options) {
   const guard = useActionGuard();
-  const signIn = (input) => guard.run(() => unref21(options.signIn)(input), "SIWX sign-in failed");
+  const signIn = (input) => guard.run(() => unref22(options.signIn)(input), "SIWX sign-in failed");
   const signOut = async () => {
     guard.reset();
-    await unref21(options.signOut)();
+    await unref22(options.signOut)();
     guard.clearError();
   };
-  const siwxResult = computed17(() => toValue20(options.result));
+  const siwxResult = computed18(() => toValue21(options.result));
   return {
-    isSignedIn: computed17(() => siwxResult.value !== null),
-    isRestoring: computed17(() => toValue20(options.isRestoring)),
+    isSignedIn: computed18(() => siwxResult.value !== null),
+    isRestoring: computed18(() => toValue21(options.isRestoring)),
     siwxResult,
     isSigningIn: guard.busy,
     error: guard.error,
@@ -1954,15 +1974,15 @@ 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 onScopeDispose13, shallowRef as shallowRef18, toValue as toValue21, watch as watch9 } from "vue";
+import { computed as computed19, onScopeDispose as onScopeDispose13, shallowRef as shallowRef18, toValue as toValue22, watch as watch9 } from "vue";
 function useBalance(account, client, options = {}) {
   const guard = useActionGuard();
   const balance = shallowRef18(null);
   const isFetching = shallowRef18(false);
   let timer = null;
   const refetch = async () => {
-    const reader = toValue21(client);
-    const address = bareEvmAddress5(toValue21(account));
+    const reader = toValue22(client);
+    const address = bareEvmAddress5(toValue22(account));
     if (!reader || !address) {
       guard.reset();
       balance.value = null;
@@ -2000,9 +2020,9 @@ function useBalance(account, client, options = {}) {
   };
   watch9(
     [
-      () => toValue21(account),
-      () => toValue21(client),
-      () => toValue21(options.refreshInterval) ?? 0
+      () => toValue22(account),
+      () => toValue22(client),
+      () => toValue22(options.refreshInterval) ?? 0
     ],
     ([, , interval]) => {
       stopTimer();
@@ -2014,10 +2034,10 @@ function useBalance(account, client, options = {}) {
   onScopeDispose13(stopTimer);
   return {
     balance,
-    formatted: computed18(
-      () => balance.value === null ? null : formatUnits2(BigInt(balance.value), toValue21(options.decimals) ?? 18)
+    formatted: computed19(
+      () => balance.value === null ? null : formatUnits2(BigInt(balance.value), toValue22(options.decimals) ?? 18)
     ),
-    symbol: computed18(() => toValue21(options.symbol) ?? null),
+    symbol: computed19(() => toValue22(options.symbol) ?? null),
     isFetching,
     error: guard.error,
     refetch
@@ -2028,7 +2048,7 @@ function useBalance(account, client, options = {}) {
 import {
   isQuotableInput
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef19, toValue as toValue22, unref as unref22, watch as watch10 } from "vue";
+import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef19, toValue as toValue23, unref as unref23, watch as watch10 } from "vue";
 function useRouteQuote(input, getQuotes, options = {}) {
   const guard = useActionGuard();
   const quotes = shallowRef19([]);
@@ -2045,7 +2065,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
       quotes.value = [];
       return null;
     }
-    const fn = unref22(getQuotes);
+    const fn = unref23(getQuotes);
     if (!fn) {
       guard.invalidate();
       loading.value = false;
@@ -2054,7 +2074,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     return fn;
   };
   const fetchQuotes = async () => {
-    const current = toValue22(input);
+    const current = toValue23(input);
     const fn = requestable(current);
     if (!fn) return;
     loading.value = true;
@@ -2091,17 +2111,17 @@ function useRouteQuote(input, getQuotes, options = {}) {
   };
   watch10(
     [
-      () => toValue22(input).fromChain,
-      () => toValue22(input).toChain,
-      () => toValue22(input).fromToken,
-      () => toValue22(input).toToken,
-      () => toValue22(input).amount,
-      () => unref22(getQuotes)
+      () => toValue23(input).fromChain,
+      () => toValue23(input).toChain,
+      () => toValue23(input).fromToken,
+      () => toValue23(input).toToken,
+      () => toValue23(input).amount,
+      () => unref23(getQuotes)
     ],
     () => {
       clearTimer();
       guard.invalidate();
-      if (!requestable(toValue22(input))) return;
+      if (!requestable(toValue23(input))) return;
       timer = setTimeout(() => {
         timer = null;
         void fetchQuotes();
@@ -2128,14 +2148,14 @@ function useRouteQuote(input, getQuotes, options = {}) {
 import {
   compareCostsKey
 } from "@naculus/connect-appkit-core";
-import { shallowRef as shallowRef20, toValue as toValue23, unref as unref23, watch as watch11 } from "vue";
+import { shallowRef as shallowRef20, toValue as toValue24, unref as unref24, watch as watch11 } from "vue";
 function useCompareCosts(input, compareCosts) {
   const guard = useActionGuard();
   const comparisons = shallowRef20([]);
   const loading = shallowRef20(false);
   const fetchComparisons = async () => {
-    const { operation, chains, options } = toValue23(input);
-    const fn = unref23(compareCosts);
+    const { operation, chains, options } = toValue24(input);
+    const fn = unref24(compareCosts);
     if (!chains || chains.length === 0) {
       guard.invalidate();
       loading.value = false;
@@ -2173,7 +2193,7 @@ function useCompareCosts(input, compareCosts) {
     });
   };
   watch11(
-    [() => compareCostsKey(toValue23(input)), () => unref23(compareCosts)],
+    [() => compareCostsKey(toValue24(input)), () => unref24(compareCosts)],
     () => {
       void fetchComparisons();
     },
@@ -2192,7 +2212,7 @@ import {
   toExecuteRouteError,
   validateRouteRecipient
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef21, unref as unref24 } from "vue";
+import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef21, unref as unref25 } from "vue";
 function useExecuteRoute(executeRoute) {
   const executing = shallowRef21(false);
   const result = shallowRef21(null);
@@ -2200,7 +2220,7 @@ function useExecuteRoute(executeRoute) {
   let inFlight = false;
   let disposed = false;
   const execute = async (quote, recipient, options) => {
-    const fn = unref24(executeRoute);
+    const fn = unref25(executeRoute);
     if (!fn) {
       error.value = {
         code: "no_executor",
@@ -2259,7 +2279,7 @@ import { eip155ChainIdToNumber } from "@naculus/connect-appkit-core";
 import {
   TokenListManager
 } from "@naculus/connect-core";
-import { shallowRef as shallowRef22, toValue as toValue24, watch as watch12 } from "vue";
+import { shallowRef as shallowRef22, toValue as toValue25, watch as watch12 } from "vue";
 function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
@@ -2269,7 +2289,7 @@ function useTokenList(chainId, options = {}) {
   const isLoading = shallowRef22(options.autoLoad !== false);
   const isLoaded = shallowRef22(false);
   const select = () => {
-    const id = toValue24(chainId);
+    const id = toValue25(chainId);
     const numeric = id ? eip155ChainIdToNumber(id) : void 0;
     return manager.getTokens(
       numeric !== void 0 ? { chainId: numeric } : void 0
@@ -2296,7 +2316,7 @@ function useTokenList(chainId, options = {}) {
     });
   };
   watch12(
-    () => toValue24(chainId),
+    () => toValue25(chainId),
     () => {
       if (options.autoLoad !== false) void run(() => manager.load());
     },
@@ -2316,7 +2336,7 @@ import { eip155ChainIdToNumber as eip155ChainIdToNumber2 } from "@naculus/connec
 import {
   TokenListManager as TokenListManager2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef23, toValue as toValue25, watch as watch13 } from "vue";
+import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef23, toValue as toValue26, watch as watch13 } from "vue";
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
@@ -2337,7 +2357,7 @@ function useTokenSearch(query, chainId, options = {}) {
     timer = null;
   };
   watch13(
-    [() => (toValue25(query) ?? "").trim(), () => toValue25(chainId)],
+    [() => (toValue26(query) ?? "").trim(), () => toValue26(chainId)],
     ([q, id]) => {
       clear();
       if (!q) {
@@ -2367,17 +2387,17 @@ function useTokenSearch(query, chainId, options = {}) {
 import {
   validateDestination
 } from "@naculus/connect-appkit-core";
-import { computed as computed19, toValue as toValue26 } from "vue";
+import { computed as computed20, toValue as toValue27 } from "vue";
 function useValidateDestination(address) {
   return {
-    validation: computed19(() => validateDestination(toValue26(address) ?? ""))
+    validation: computed20(() => validateDestination(toValue27(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 onScopeDispose17, shallowRef as shallowRef24, toValue as toValue27, watch as watch14 } from "vue";
+import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef24, toValue as toValue28, watch as watch14 } from "vue";
 function tokensKey(tokens) {
   return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
 }
@@ -2387,9 +2407,9 @@ function useTokenBalance(account, client, tokens, options = {}) {
   const isFetching = shallowRef24(false);
   let timer = null;
   const refetch = async () => {
-    const reader = toValue27(client);
-    const address = bareEvmAddress6(toValue27(account));
-    const list = toValue27(tokens) ?? [];
+    const reader = toValue28(client);
+    const address = bareEvmAddress6(toValue28(account));
+    const list = toValue28(tokens) ?? [];
     if (!reader || !address || list.length === 0) {
       guard.reset();
       tokenBalances.value = [];
@@ -2446,10 +2466,10 @@ function useTokenBalance(account, client, tokens, options = {}) {
   };
   watch14(
     [
-      () => toValue27(account),
-      () => toValue27(client),
-      () => tokensKey(toValue27(tokens) ?? []),
-      () => toValue27(options.refreshInterval) ?? 0
+      () => toValue28(account),
+      () => toValue28(client),
+      () => tokensKey(toValue28(tokens) ?? []),
+      () => toValue28(options.refreshInterval) ?? 0
     ],
     ([, , , interval]) => {
       stopTimer();
@@ -2478,7 +2498,7 @@ import {
   REVOKE_DELEGATE,
   WalletError as WalletError7
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef25, toValue as toValue28, watch as watch15 } from "vue";
+import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef25, toValue as toValue29, watch as watch15 } from "vue";
 function useDelegate(options) {
   const result = shallowRef25(null);
   const isPending = shallowRef25(false);
@@ -2492,15 +2512,15 @@ function useDelegate(options) {
   };
   const run = async (target, allowlist) => {
     if (inFlight) return fail(new Error("A delegation is already in progress"));
-    const session = toValue28(options.session);
-    const account = bareEvmAddress7(toValue28(options.account));
-    const chainId = toValue28(options.chainId);
+    const session = toValue29(options.session);
+    const account = bareEvmAddress7(toValue29(options.account));
+    const chainId = toValue29(options.chainId);
     if (!session || !account || !chainId) {
       return fail(
         new WalletError7("wallet_unavailable", "No connected EVM account")
       );
     }
-    const reader = toValue28(options.client);
+    const reader = toValue29(options.client);
     if (!reader || reader.chain?.id !== eip155Reference(chainId)) {
       return fail(
         new WalletError7(
@@ -2509,7 +2529,7 @@ function useDelegate(options) {
         )
       );
     }
-    const connector = toValue28(options.connector) ?? {};
+    const connector = toValue29(options.connector) ?? {};
     const own = ++requestId;
     inFlight = true;
     isPending.value = true;
@@ -2546,9 +2566,9 @@ function useDelegate(options) {
   };
   watch15(
     [
-      () => toValue28(options.session),
-      () => toValue28(options.account),
-      () => toValue28(options.chainId)
+      () => toValue29(options.session),
+      () => toValue29(options.account),
+      () => toValue29(options.chainId)
     ],
     reset,
     { flush: "sync" }
@@ -2558,7 +2578,7 @@ function useDelegate(options) {
     requestId++;
   });
   return {
-    delegate: (target) => run(target, toValue28(options.allowlist)),
+    delegate: (target) => run(target, toValue29(options.allowlist)),
     revoke: () => run(REVOKE_DELEGATE, []),
     result,
     isPending,
@@ -2573,14 +2593,14 @@ import {
   readDelegation,
   UNKNOWN_DELEGATION
 } from "@naculus/connect-core";
-import { computed as computed20, shallowRef as shallowRef26, toValue as toValue29, watch as watch16 } from "vue";
+import { computed as computed21, shallowRef as shallowRef26, toValue as toValue30, watch as watch16 } from "vue";
 function useDelegation(account, client, chainId) {
   const guard = useActionGuard();
   const status = shallowRef26(UNKNOWN_DELEGATION);
   const isFetching = shallowRef26(false);
   const refetch = async () => {
-    const reader = toValue29(client);
-    const address = bareEvmAddress8(toValue29(account));
+    const reader = toValue30(client);
+    const address = bareEvmAddress8(toValue30(account));
     status.value = UNKNOWN_DELEGATION;
     if (!reader || !address) {
       guard.reset();
@@ -2613,15 +2633,15 @@ function useDelegation(account, client, chainId) {
     });
   };
   watch16(
-    [() => toValue29(account), () => toValue29(client), () => toValue29(chainId)],
+    [() => toValue30(account), () => toValue30(client), () => toValue30(chainId)],
     () => {
       void refetch();
     },
     { immediate: true, flush: "sync" }
   );
   return {
-    delegated: computed20(() => status.value.delegated),
-    delegate: computed20(() => status.value.delegate),
+    delegated: computed21(() => status.value.delegated),
+    delegate: computed21(() => status.value.delegate),
     isFetching,
     error: guard.error,
     refetch
@@ -2634,7 +2654,7 @@ import {
   DEFAULT_VERIFY_RETRY,
   describePayment
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef27, unref as unref25 } from "vue";
+import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef27, unref as unref26 } from "vue";
 function usePaymentFetch(pay, options = {}) {
   const guard = useActionGuard();
   const lastPayment = shallowRef27(null);
@@ -2645,7 +2665,7 @@ function usePaymentFetch(pay, options = {}) {
     verification++;
   });
   const payFetch = (input, init) => {
-    const invoke = unref25(pay);
+    const invoke = unref26(pay);
     const own = epoch;
     return guard.run(async () => {
       const result = await invoke(input, init);
@@ -2712,9 +2732,9 @@ import {
   readMppRecoveryChannelId,
   readMppSessionReceipt
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose20, shallowRef as shallowRef28, unref as unref26, watch as watch17 } from "vue";
+import { onScopeDispose as onScopeDispose20, shallowRef as shallowRef28, unref as unref27, watch as watch17 } from "vue";
 function useMppSession(session) {
-  const current = () => unref26(session);
+  const current = () => unref27(session);
   const pending = shallowRef28(current().meter.pending);
   const channel = shallowRef28(
     readCurrentMppSessionChannel(current())
@@ -2728,7 +2748,7 @@ function useMppSession(session) {
   let epoch = 0;
   let disposed = false;
   watch17(
-    () => unref26(session),
+    () => unref27(session),
     (value) => {
       generation++;
       epoch++;
@@ -2841,7 +2861,7 @@ function useMppSession(session) {
 import {
   createSolanaSessionKeyFlow
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose21, shallowRef as shallowRef29, unref as unref27, watch as watch18 } from "vue";
+import { onScopeDispose as onScopeDispose21, shallowRef as shallowRef29, unref as unref28, watch as watch18 } from "vue";
 function useSolanaSessionKey(deps) {
   const guard = useActionGuard();
   const keys = shallowRef29([]);
@@ -2857,7 +2877,7 @@ function useSolanaSessionKey(deps) {
     if (!disposed && own === generation) keys.value = next;
   };
   watch18(
-    () => unref27(deps),
+    () => unref28(deps),
     (next) => {
       flow = next ? createSolanaSessionKeyFlow(next) : null;
       guard.invalidate();
@@ -2891,16 +2911,16 @@ function useSolanaSessionKey(deps) {
 
 // src/name-lookup.ts
 import { getResolver } from "@naculus/connect-appkit-core";
-import { computed as computed21, shallowRef as shallowRef30, toValue as toValue30, watch as watch19 } from "vue";
+import { computed as computed22, shallowRef as shallowRef30, toValue as toValue31, watch as watch19 } from "vue";
 function useNameLookup(options) {
   const guard = useActionGuard();
   const data = shallowRef30(null);
   const loading = shallowRef30(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 input = toValue31(options.input).trim();
+    const skip = toValue31(options.skip) ?? false;
+    const scope = toValue31(options.scope);
+    const config = toValue31(options.resolverConfig);
     if (!input || skip) {
       guard.reset();
       data.value = null;
@@ -2937,17 +2957,17 @@ function useNameLookup(options) {
   };
   watch19(
     () => [
-      toValue30(options.input),
-      toValue30(options.skip),
-      toValue30(options.scope),
-      toValue30(options.resolverConfig)
+      toValue31(options.input),
+      toValue31(options.skip),
+      toValue31(options.scope),
+      toValue31(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
   return {
     data,
-    isLoading: computed21(() => loading.value),
+    isLoading: computed22(() => loading.value),
     error: guard.error,
     refetch: run
   };
@@ -2975,21 +2995,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-import { computed as computed22, toValue as toValue31 } from "vue";
+import { computed as computed23, toValue as toValue32 } from "vue";
 function useSolanaAccount(accounts, connected) {
-  const isConnected = computed22(() => toValue31(connected));
-  const caip10 = computed22(
-    () => isConnected.value ? (toValue31(accounts) ?? []).find(
+  const isConnected = computed23(() => toValue32(connected));
+  const caip10 = computed23(
+    () => isConnected.value ? (toValue32(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
-  const parts = computed22(() => caip10.value?.split(":") ?? []);
+  const parts = computed23(() => caip10.value?.split(":") ?? []);
   return {
-    address: computed22(
+    address: computed23(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: computed22(
+    chainId: computed23(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -3004,19 +3024,19 @@ import {
   describeChain,
   resolveChain
 } from "@naculus/connect-appkit-core";
-import { computed as computed23, toValue as toValue32 } from "vue";
+import { computed as computed24, toValue as toValue33 } from "vue";
 function useChain(chains, chainId) {
-  const list = computed23(() => toValue32(chains) ?? []);
-  const id = computed23(() => toValue32(chainId) ?? null);
-  const currentChain = computed23(() => resolveChain(list.value, id.value));
+  const list = computed24(() => toValue33(chains) ?? []);
+  const id = computed24(() => toValue33(chainId) ?? null);
+  const currentChain = computed24(() => resolveChain(list.value, id.value));
   return {
     currentChain,
-    chainInfo: computed23(() => describeChain(list.value, id.value)),
-    availableChains: computed23(() => chainsForNamespace(list.value, id.value)),
-    currentChainNumber: computed23(
+    chainInfo: computed24(() => describeChain(list.value, id.value)),
+    availableChains: computed24(() => chainsForNamespace(list.value, id.value)),
+    currentChainNumber: computed24(
       () => currentChain.value ? chainNumber2(currentChain.value) : null
     ),
-    namespace: computed23(
+    namespace: computed24(
       () => currentChain.value ? chainNamespace(currentChain.value) : null
     )
   };
@@ -3040,14 +3060,14 @@ function usePassphraseGate(gate) {
 
 // src/useSolanaBalance.ts
 import { getSolanaBalance } from "@naculus/connect-core";
-import { ref, shallowRef as shallowRef32, toValue as toValue33, watchEffect } from "vue";
+import { ref, shallowRef as shallowRef32, toValue as toValue34, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
   const guard = useActionGuard();
   const balance = shallowRef32(null);
   const isFetching = ref(false);
   const refetch = async () => {
-    const addr = toValue33(address);
-    const url = toValue33(rpcUrl);
+    const addr = toValue34(address);
+    const url = toValue34(rpcUrl);
     if (!addr || !url) {
       guard.invalidate();
       isFetching.value = false;
@@ -3080,21 +3100,21 @@ function useSolanaBalance(address, rpcUrl) {
     });
   };
   watchEffect(() => {
-    toValue33(address);
-    toValue33(rpcUrl);
+    toValue34(address);
+    toValue34(rpcUrl);
     void refetch();
   });
   return { balance, isFetching, error: guard.error, refetch };
 }
 
 // src/useLastTx.ts
-import { shallowRef as shallowRef33, toValue as toValue34, watch as watch20 } from "vue";
+import { shallowRef as shallowRef33, toValue as toValue35, watch as watch20 } from "vue";
 function useLastTx(monitor) {
   const lastTx = shallowRef33(null);
   const lastConfirmedTx = shallowRef33(null);
   const lastFailedTx = shallowRef33(null);
   watch20(
-    () => toValue34(monitor),
+    () => toValue35(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -3132,13 +3152,13 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-import { computed as computed24, shallowRef as shallowRef34, toValue as toValue35, watch as watch21 } from "vue";
+import { computed as computed25, shallowRef as shallowRef34, toValue as toValue36, watch as watch21 } from "vue";
 function useTxHistory(address, chainId, monitor) {
   const guard = useActionGuard();
   const entries = shallowRef34([]);
   const isLoading = shallowRef34(false);
   const refresh = async () => {
-    const activeMonitor = toValue35(monitor);
+    const activeMonitor = toValue36(monitor);
     if (!activeMonitor) {
       guard.reset();
       entries.value = [];
@@ -3149,8 +3169,8 @@ function useTxHistory(address, chainId, monitor) {
     await guard.run(
       async (commit) => {
         const result = await activeMonitor.getTxHistory(
-          toValue35(address) ?? void 0,
-          toValue35(chainId) ?? void 0
+          toValue36(address) ?? void 0,
+          toValue36(chainId) ?? void 0
         );
         commit(() => {
           entries.value = result;
@@ -3167,7 +3187,7 @@ function useTxHistory(address, chainId, monitor) {
     });
   };
   watch21(
-    [() => toValue35(monitor), () => toValue35(address), () => toValue35(chainId)],
+    [() => toValue36(monitor), () => toValue36(address), () => toValue36(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -3187,7 +3207,7 @@ function useTxHistory(address, chainId, monitor) {
     isLoading,
     error: guard.error,
     refresh,
-    summary: computed24(() => ({
+    summary: computed25(() => ({
       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
@@ -3196,7 +3216,7 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-import { computed as computed25, shallowRef as shallowRef35, toValue as toValue36, watch as watch22 } from "vue";
+import { computed as computed26, shallowRef as shallowRef35, toValue as toValue37, watch as watch22 } from "vue";
 function useTxMonitor(hash, chainId, monitor) {
   const entry = shallowRef35(null);
   const isLoading = shallowRef35(false);
@@ -3206,15 +3226,15 @@ function useTxMonitor(hash, chainId, monitor) {
   let generation = 0;
   let refreshed = [];
   const currentInputs = () => [
-    toValue36(monitor),
-    toValue36(hash),
-    toValue36(chainId)
+    toValue37(monitor),
+    toValue37(hash),
+    toValue37(chainId)
   ];
   const sameInputs = (a, b) => a.every((value, i) => Object.is(value, b[i]));
   const refresh = async () => {
-    const activeMonitor = toValue36(monitor);
-    const activeHash = toValue36(hash);
-    const activeChainId = toValue36(chainId);
+    const activeMonitor = toValue37(monitor);
+    const activeHash = toValue37(hash);
+    const activeChainId = toValue37(chainId);
     if (!activeMonitor || !activeHash) return;
     const started = [activeMonitor, activeHash, activeChainId];
     refreshed = started;
@@ -3250,15 +3270,15 @@ function useTxMonitor(hash, chainId, monitor) {
     });
   };
   const stopWatching = () => {
-    const activeMonitor = toValue36(monitor);
-    const activeHash = toValue36(hash);
-    const activeChainId = toValue36(chainId);
+    const activeMonitor = toValue37(monitor);
+    const activeHash = toValue37(hash);
+    const activeChainId = toValue37(chainId);
     if (!activeMonitor || !activeHash) return;
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
   watch22(
-    [() => toValue36(monitor), () => toValue36(hash), () => toValue36(chainId)],
+    [() => toValue37(monitor), () => toValue37(hash), () => toValue37(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
       if (!sameInputs([activeMonitor, activeHash, activeChainId], refreshed)) {
@@ -3300,7 +3320,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: computed25(() => entry.value?.status ?? "idle"),
+    status: computed26(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -3315,7 +3335,7 @@ import {
   normalizeCapabilities,
   selectChainCapabilities
 } from "@naculus/connect-appkit-core";
-import { computed as computed26, shallowRef as shallowRef36, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
+import { computed as computed27, shallowRef as shallowRef36, toValue as toValue38, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
   const guard = useActionGuard();
   const capabilities = shallowRef36(
@@ -3323,8 +3343,8 @@ function useCapabilities(client, session, chainId) {
   );
   const isFetching = shallowRef36(false);
   const refetch = async () => {
-    const activeClient = toValue37(client);
-    const activeSession = toValue37(session);
+    const activeClient = toValue38(client);
+    const activeSession = toValue38(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       guard.reset();
       capabilities.value = null;
@@ -3357,17 +3377,17 @@ function useCapabilities(client, session, chainId) {
     });
   };
   watchEffect2(() => {
-    void toValue37(client);
-    void toValue37(session);
+    void toValue38(client);
+    void toValue38(session);
     void refetch();
   });
   return {
     capabilities,
-    current: computed26(
-      () => selectChainCapabilities(capabilities.value, toValue37(chainId))
+    current: computed27(
+      () => selectChainCapabilities(capabilities.value, toValue38(chainId))
     ),
-    atomic: computed26(
-      () => atomicSupportFor(capabilities.value, toValue37(chainId))
+    atomic: computed27(
+      () => atomicSupportFor(capabilities.value, toValue38(chainId))
     ),
     isFetching,
     error: guard.error,
@@ -3379,17 +3399,17 @@ function useCapabilities(client, session, chainId) {
 import {
   readSolanaRoles
 } from "@naculus/connect-appkit-core";
-import { computed as computed27, toValue as toValue38 } from "vue";
+import { computed as computed28, toValue as toValue39 } from "vue";
 function useSolanaRoles(connector, session) {
-  const state = computed27(
-    () => readSolanaRoles(toValue38(connector), toValue38(session))
+  const state = computed28(
+    () => readSolanaRoles(toValue39(connector), toValue39(session))
   );
   return {
-    roles: computed27(() => state.value.roles),
-    absence: computed27(() => state.value.absence),
-    identity: computed27(() => state.value.roles?.identity ?? null),
-    signer: computed27(() => state.value.roles?.signer ?? null),
-    payer: computed27(() => state.value.roles?.payer ?? null)
+    roles: computed28(() => state.value.roles),
+    absence: computed28(() => state.value.absence),
+    identity: computed28(() => state.value.roles?.identity ?? null),
+    signer: computed28(() => state.value.roles?.signer ?? null),
+    payer: computed28(() => state.value.roles?.payer ?? null)
   };
 }
 export {
@@ -3476,6 +3496,7 @@ export {
   useTxHistory,
   useTxMonitor,
   useUserOpStatus,
-  useValidateDestination
+  useValidateDestination,
+  useX402Signer
 };
 //# sourceMappingURL=index.js.map