@getpara/react-sdk-lite 2.20.0 → 2.22.0

package/dist/aa/hooks/alchemy.d.ts

@@ -1,4 +1,7 @@
 import { ALCHEMY_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseAlchemySmartAccountParams } from '@getpara/aa-alchemy';
 export { ALCHEMY_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage an Alchemy smart account.
@@ -10,6 +13,6 @@ export { ALCHEMY_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useAlchemySmartAccount: (params?: import("@getpara/aa-alchemy").AlchemySmartAccountConfig & {
+export declare const useAlchemySmartAccount: (params?: UseAlchemySmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/biconomy.d.ts

@@ -1,4 +1,7 @@
 import { BICONOMY_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseBiconomySmartAccountParams } from '@getpara/aa-biconomy';
 export { BICONOMY_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Biconomy smart account.
@@ -10,6 +13,6 @@ export { BICONOMY_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useBiconomySmartAccount: (params?: import("@getpara/aa-biconomy").BiconomySmartAccountConfig & {
+export declare const useBiconomySmartAccount: (params?: UseBiconomySmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/cdp.d.ts

@@ -1,4 +1,7 @@
 import { CDP_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseCDPSmartAccountParams } from '@getpara/aa-cdp';
 export { CDP_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Coinbase Developer Platform smart account.
@@ -9,6 +12,6 @@ export { CDP_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useCDPSmartAccount: (params?: import("@getpara/aa-cdp").CDPSmartAccountConfig & {
+export declare const useCDPSmartAccount: (params?: UseCDPSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/gelato.d.ts

@@ -1,4 +1,7 @@
 import { GELATO_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseGelatoSmartAccountParams } from '@getpara/aa-gelato';
 export { GELATO_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Gelato smart account.
@@ -9,6 +12,6 @@ export { GELATO_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useGelatoSmartAccount: (params?: import("@getpara/aa-gelato").GelatoSmartAccountConfig & {
+export declare const useGelatoSmartAccount: (params?: UseGelatoSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/pimlico.d.ts

@@ -1,4 +1,7 @@
 import { PIMLICO_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UsePimlicoSmartAccountParams } from '@getpara/aa-pimlico';
 export { PIMLICO_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Pimlico smart account.
@@ -10,6 +13,6 @@ export { PIMLICO_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const usePimlicoSmartAccount: (params?: import("@getpara/aa-pimlico").PimlicoSmartAccountConfig & {
+export declare const usePimlicoSmartAccount: (params?: UsePimlicoSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/porto.d.ts

@@ -1,4 +1,7 @@
 import { PORTO_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UsePortoSmartAccountParams } from '@getpara/aa-porto';
 export { PORTO_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Porto smart account.
@@ -10,6 +13,6 @@ export { PORTO_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const usePortoSmartAccount: (params?: import("@getpara/aa-porto").PortoAccountConfig & {
+export declare const usePortoSmartAccount: (params?: UsePortoSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/rhinestone.d.ts

@@ -1,4 +1,7 @@
 import { RHINESTONE_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseRhinestoneSmartAccountParams } from '@getpara/aa-rhinestone';
 export { RHINESTONE_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Rhinestone smart account.
@@ -10,6 +13,6 @@ export { RHINESTONE_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useRhinestoneSmartAccount: (params?: import("@getpara/aa-rhinestone").RhinestoneSmartAccountConfig & {
+export declare const useRhinestoneSmartAccount: (params?: UseRhinestoneSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/safe.d.ts

@@ -1,4 +1,7 @@
 import { SAFE_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseSafeSmartAccountParams } from '@getpara/aa-safe';
 export { SAFE_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Safe smart account.
@@ -10,6 +13,6 @@ export { SAFE_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useSafeSmartAccount: (params?: import("@getpara/aa-safe").SafeSmartAccountConfig & {
+export declare const useSafeSmartAccount: (params?: UseSafeSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/thirdweb.d.ts

@@ -1,4 +1,7 @@
 import { THIRDWEB_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseThirdwebSmartAccountParams } from '@getpara/aa-thirdweb';
 export { THIRDWEB_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a Thirdweb smart account.
@@ -10,4 +13,6 @@ export { THIRDWEB_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useThirdwebSmartAccount: (params?: any) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+export declare const useThirdwebSmartAccount: (params?: UseThirdwebSmartAccountParams & {
+    enabled?: boolean;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/aa/hooks/zerodev.d.ts

@@ -1,4 +1,7 @@
 import { ZERODEV_SMART_ACCOUNT_BASE_KEY } from '@getpara/react-core/internal';
+import type { UseSmartAccountResult } from '@getpara/react-core/internal';
+import type { SmartAccount } from '@getpara/viem-v2-integration/aa';
+import type { UseZeroDevSmartAccountParams } from '@getpara/aa-zerodev';
 export { ZERODEV_SMART_ACCOUNT_BASE_KEY };
 /**
  * React / React Native hook to create and manage a ZeroDev smart account.
@@ -10,6 +13,6 @@ export { ZERODEV_SMART_ACCOUNT_BASE_KEY };
  * On web, automatically detects connected external wallets (MetaMask, etc.) via wagmi
  * and uses them as the signer when no Para embedded wallet is active.
  */
-export declare const useZeroDevSmartAccount: (params?: import("@getpara/aa-zerodev").ZeroDevSmartAccountConfig & {
+export declare const useZeroDevSmartAccount: (params?: UseZeroDevSmartAccountParams & {
     enabled?: boolean;
-}) => import("@getpara/react-core/internal").UseSmartAccountResult<import("@getpara/aa-alchemy").SmartAccount>;
+}) => UseSmartAccountResult<SmartAccount>;

package/dist/chains/cosmos.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Returns a CosmJS `OfflineDirectSigner` for the user's Cosmos wallet.
+ * Supports both embedded Para wallets and external wallets.
+ *
+ * If the user has multiple Cosmos wallets, pass `address` or `walletId` to select one.
+ * When omitted, the active wallet from `useWalletState` is used automatically.
+ *
+ * @example
+ * ```tsx
+ * import { useParaCosmjsProtoSigner } from "@getpara/react-sdk";
+ * import { SigningStargateClient } from "@cosmjs/stargate";
+ *
+ * function SignDirect() {
+ *   const { protoSigner, isLoading } = useParaCosmjsProtoSigner();
+ *
+ *   const handleSign = async () => {
+ *     if (!protoSigner) return;
+ *     const client = await SigningStargateClient.connectWithSigner(rpcUrl, protoSigner);
+ *     const result = await protoSigner.signDirect(protoSigner.address, signDoc);
+ *     console.log(result);
+ *   };
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   return <button onClick={handleSign}>Sign</button>;
+ * }
+ * ```
+ *
+ */
+export declare const useParaCosmjsProtoSigner: ({ address, prefix, walletId, messageSigningTimeoutMs, }?: import("@getpara/react-core/dist/chains/types.js").WalletSelector & {
+    prefix?: string;
+    messageSigningTimeoutMs?: number;
+}) => import("@getpara/react-core/dist/chains/cosmos/useParaCosmjsProtoSigner.js").UseParaCosmjsProtoSignerReturn;
+/**
+ * Returns a CosmJS `OfflineAminoSigner` for the user's Cosmos wallet.
+ * Supports both embedded Para wallets and external wallets.
+ *
+ * If the user has multiple Cosmos wallets, pass `address` or `walletId` to select one.
+ * When omitted, the active wallet from `useWalletState` is used automatically.
+ *
+ * @example
+ * ```tsx
+ * import { useParaCosmjsAminoSigner } from "@getpara/react-sdk";
+ *
+ * function SignAmino() {
+ *   const { aminoSigner, isLoading } = useParaCosmjsAminoSigner();
+ *
+ *   const handleSign = async () => {
+ *     if (!aminoSigner) return;
+ *     const result = await aminoSigner.signAmino(aminoSigner.address, signDoc);
+ *     console.log(result);
+ *   };
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   return <button onClick={handleSign}>Sign</button>;
+ * }
+ * ```
+ *
+ */
+export declare const useParaCosmjsAminoSigner: ({ address, prefix, walletId, messageSigningTimeoutMs, }?: import("@getpara/react-core/dist/chains/types.js").WalletSelector & {
+    prefix?: string;
+    messageSigningTimeoutMs?: number;
+}) => import("@getpara/react-core/dist/chains/cosmos/useParaCosmjsAminoSigner.js").UseParaCosmjsAminoSignerReturn;

package/dist/chains/cosmos.js

@@ -0,0 +1,10 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { createParaCosmjsProtoSignerHook, createParaCosmjsAminoSignerHook } from "@getpara/react-core/cosmos";
+import { useGrazEnhancer } from "./useGrazEnhancer.js";
+const useParaCosmjsProtoSigner = createParaCosmjsProtoSignerHook(useGrazEnhancer);
+const useParaCosmjsAminoSigner = createParaCosmjsAminoSignerHook(useGrazEnhancer);
+export {
+  useParaCosmjsAminoSigner,
+  useParaCosmjsProtoSigner
+};

package/dist/chains/evm.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Returns a viem `WalletClient` for the user's EVM wallet.
+ * Supports both embedded Para wallets and external wallets.
+ *
+ * If the user has multiple EVM wallets, pass `address` or `walletId` to select one.
+ * When omitted, the active wallet from `useWalletState` is used automatically.
+ *
+ * @example
+ * ```tsx
+ * import { useParaViemClient } from "@getpara/react-sdk";
+ * import { sepolia } from "viem/chains";
+ * import { http } from "viem";
+ *
+ * function SignMessage() {
+ *   const { viemClient, isLoading } = useParaViemClient({
+ *     walletClientConfig: { chain: sepolia, transport: http() },
+ *   });
+ *
+ *   const handleSign = async () => {
+ *     if (!viemClient) return;
+ *     const signature = await viemClient.signMessage({ message: "Hello" });
+ *     console.log(signature);
+ *   };
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   return <button onClick={handleSign}>Sign Message</button>;
+ * }
+ * ```
+ *
+ */
+export declare const useParaViemClient: (params: import("@getpara/react-core/dist/chains/types.js").WalletSelector & {
+    walletClientConfig: Omit<import("viem").WalletClientConfig, "account">;
+}) => import("@getpara/react-core/dist/chains/evm/viem/useParaViemClient.js").UseParaViemClientReturn;
+/**
+ * Returns a viem `LocalAccount` for the user's EVM wallet.
+ * Supports both embedded Para wallets and external wallets.
+ *
+ * If the user has multiple EVM wallets, pass `address` or `walletId` to select one.
+ * When omitted, the active wallet from `useWalletState` is used automatically.
+ *
+ * @example
+ * ```tsx
+ * import { useParaViemAccount } from "@getpara/react-sdk";
+ *
+ * function WalletAddress() {
+ *   const { viemAccount, isLoading } = useParaViemAccount();
+ *   if (isLoading) return <p>Loading...</p>;
+ *   return <p>{viemAccount?.address ?? "No wallet"}</p>;
+ * }
+ * ```
+ *
+ */
+export declare const useParaViemAccount: ({ address, walletId }?: import("@getpara/react-core/dist/chains/types.js").WalletSelector) => import("@getpara/react-core/dist/chains/evm/viem/useParaViemAccount.js").UseParaViemAccountReturn;
+/**
+ * Returns an ethers.js `Signer` for the user's EVM wallet.
+ * Supports both embedded Para wallets and external wallets (via wagmi → BrowserProvider).
+ *
+ * @example
+ * ```tsx
+ * import { useParaEthersSigner } from "@getpara/react-sdk";
+ * import { JsonRpcProvider } from "ethers";
+ *
+ * const provider = new JsonRpcProvider("https://ethereum-sepolia-rpc.publicnode.com");
+ *
+ * function SignWithEthers() {
+ *   const { ethersSigner, isLoading } = useParaEthersSigner({ provider });
+ *   // ethersSigner works with both embedded and external wallets
+ * }
+ * ```
+ */
+export declare const useParaEthersSigner: ({ address, walletId, provider, messageSigningTimeoutMs, }?: import("@getpara/react-core/dist/chains/types.js").WalletSelector & {
+    provider?: unknown;
+    messageSigningTimeoutMs?: number;
+}) => import("@getpara/react-core/dist/chains/evm/ethers/useParaEthersSigner.js").UseParaEthersSignerReturn;

package/dist/chains/evm.js

@@ -0,0 +1,14 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { createParaViemClientHook, createParaViemAccountHook } from "@getpara/react-core/evm/viem";
+import { createParaEthersSignerHook } from "@getpara/react-core/evm/ethers";
+import { useWagmiViemEnhancer } from "./useWagmiViemEnhancer.js";
+import { useWagmiEthersEnhancer } from "./useWagmiEthersEnhancer.js";
+const useParaViemClient = createParaViemClientHook(useWagmiViemEnhancer);
+const useParaViemAccount = createParaViemAccountHook(useWagmiViemEnhancer);
+const useParaEthersSigner = createParaEthersSignerHook(useWagmiEthersEnhancer);
+export {
+  useParaEthersSigner,
+  useParaViemAccount,
+  useParaViemClient
+};

package/dist/chains/solana.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns a Solana signer for the user's Solana wallet.
+ * Supports both embedded Para wallets and external wallets.
+ *
+ * If the user has multiple Solana wallets, pass `address` or `walletId` to select one.
+ * When omitted, the active wallet from `useWalletState` is used automatically.
+ *
+ * @example
+ * ```tsx
+ * import { useParaSolanaSigner } from "@getpara/react-sdk";
+ * import { createSolanaRpc } from "@solana/kit";
+ *
+ * const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
+ *
+ * function SignMessage() {
+ *   const { solanaSigner, isLoading } = useParaSolanaSigner({ rpc });
+ *
+ *   const handleSign = async () => {
+ *     if (!solanaSigner) return;
+ *     const message = new TextEncoder().encode("Hello");
+ *     const [signatures] = await solanaSigner.signMessages([{ content: message, signatures: {} }]);
+ *     console.log(signatures);
+ *   };
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   return <button onClick={handleSign}>Sign Message</button>;
+ * }
+ * ```
+ *
+ */
+export declare const useParaSolanaSigner: ({ address, walletId, rpc }: import("@getpara/react-core/dist/chains/types.js").WalletSelector & {
+    rpc: import("@getpara/solana-signers-v2-integration").ParaSignerParams["rpc"];
+}) => import("@getpara/react-core/dist/chains/solana/useParaSolanaSigner.js").UseParaSolanaSignerReturn;

package/dist/chains/solana.js

@@ -0,0 +1,8 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { createParaSolanaSignerHook } from "@getpara/react-core/solana";
+import { useSolanaWalletEnhancer } from "./useSolanaWalletEnhancer.js";
+const useParaSolanaSigner = createParaSolanaSignerHook(useSolanaWalletEnhancer);
+export {
+  useParaSolanaSigner
+};

package/dist/chains/stellar.d.ts

@@ -0,0 +1,2 @@
+export { useParaStellarSigner, STELLAR_SIGNER_BASE_KEY, useParaStellarSignTransaction, STELLAR_SIGN_TRANSACTION_KEY, } from '@getpara/react-core/stellar';
+export type { StellarEnhancement } from '@getpara/react-core/stellar';

package/dist/chains/stellar.js

@@ -0,0 +1,14 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import {
+  useParaStellarSigner,
+  STELLAR_SIGNER_BASE_KEY,
+  useParaStellarSignTransaction,
+  STELLAR_SIGN_TRANSACTION_KEY
+} from "@getpara/react-core/stellar";
+export {
+  STELLAR_SIGNER_BASE_KEY,
+  STELLAR_SIGN_TRANSACTION_KEY,
+  useParaStellarSignTransaction,
+  useParaStellarSigner
+};

package/dist/chains/useGrazEnhancer.d.ts

@@ -0,0 +1,7 @@
+import type { CosmosEnhancement } from '@getpara/react-core/cosmos';
+/**
+ * Graz-based enhancer for Cosmos chain hooks (useParaCosmjsProtoSigner, useParaCosmjsAminoSigner).
+ * When an external Cosmos wallet is connected via graz/Keplr, provides the external wallet's
+ * offline signers so the chain hooks return them instead of creating a Para signer.
+ */
+export declare function useGrazEnhancer(): CosmosEnhancement;

package/dist/chains/useGrazEnhancer.js

@@ -0,0 +1,28 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { useContext } from "react";
+import { useStore } from "../provider/stores/useStore.js";
+function useGrazEnhancer() {
+  var _a, _b;
+  const cosmosContext = useStore((state) => state.cosmosContext);
+  const ctxValue = useContext(cosmosContext);
+  const noopUseAccount = () => void 0;
+  const useCosmosAccount = (_a = ctxValue == null ? void 0 : ctxValue.useAccount) != null ? _a : noopUseAccount;
+  const account = useCosmosAccount();
+  const acct = account;
+  const isExternalConnected = !!(acct == null ? void 0 : acct.bech32Address);
+  const noopUseOfflineSigners = () => ({
+    data: void 0
+  });
+  const useOfflineSigners = (_b = ctxValue == null ? void 0 : ctxValue.useOfflineSigners) != null ? _b : noopUseOfflineSigners;
+  const { data: signersRecord } = useOfflineSigners();
+  const signers = signersRecord ? Object.values(signersRecord)[0] : void 0;
+  return {
+    protoSigner: isExternalConnected && signers ? signers.offlineSigner : null,
+    aminoSigner: isExternalConnected && signers ? signers.offlineSignerAmino : null,
+    isLoading: isExternalConnected && !signers
+  };
+}
+export {
+  useGrazEnhancer
+};

package/dist/chains/useSolanaWalletEnhancer.d.ts

@@ -0,0 +1,7 @@
+import type { SolanaEnhancement } from '@getpara/react-core/solana';
+/**
+ * Solana wallet adapter enhancer for Solana chain hooks (useParaSolanaSigner).
+ * When an external Solana wallet is connected (e.g. Phantom via wallet-adapter),
+ * provides a wrapped signer that implements the same interface as ParaSolanaSigner.
+ */
+export declare function useSolanaWalletEnhancer(): SolanaEnhancement;

package/dist/chains/useSolanaWalletEnhancer.js

@@ -0,0 +1,53 @@
+"use client";
+import {
+  __async
+} from "../chunk-MMUBH76A.js";
+import { useContext, useMemo } from "react";
+import { useStore } from "../provider/stores/useStore.js";
+function wrapWalletAdapter(wallet) {
+  const address = wallet.publicKey.toBase58();
+  return {
+    address,
+    // MessagePartialSigner
+    signMessages(messages) {
+      return __async(this, null, function* () {
+        const results = [];
+        for (const msg of messages) {
+          const sig = yield wallet.signMessage(msg.content);
+          results.push({ [address]: sig });
+        }
+        return results;
+      });
+    },
+    // TransactionPartialSigner
+    signTransactions(transactions, _config) {
+      return __async(this, null, function* () {
+        if (wallet.signAllTransactions) {
+          return wallet.signAllTransactions(transactions);
+        }
+        return Promise.all(transactions.map((tx) => wallet.signTransaction(tx)));
+      });
+    }
+  };
+}
+function useSolanaWalletEnhancer() {
+  var _a, _b;
+  const solanaContext = useStore((state) => state.solanaContext);
+  const ctxValue = useContext(solanaContext);
+  const noopUseWallet = () => void 0;
+  const useSolanaWallet = (_a = ctxValue == null ? void 0 : ctxValue.useWallet) != null ? _a : noopUseWallet;
+  const wallet = useSolanaWallet();
+  const w = wallet;
+  const isExternalConnected = !!(w == null ? void 0 : w.connected) && !!(w == null ? void 0 : w.publicKey);
+  const wrappedSigner = useMemo(
+    () => isExternalConnected ? wrapWalletAdapter(wallet) : null,
+    [isExternalConnected, (_b = w == null ? void 0 : w.publicKey) == null ? void 0 : _b.toBase58()]
+  );
+  return {
+    signer: wrappedSigner,
+    isLoading: false
+  };
+}
+export {
+  useSolanaWalletEnhancer
+};

package/dist/chains/useWagmiEthersEnhancer.d.ts

@@ -0,0 +1,7 @@
+import type { EthersEnhancement } from '@getpara/react-core/evm/ethers';
+/**
+ * Wagmi-based enhancer for the ethers chain hooks (useParaEthersSigner).
+ * When an external EVM wallet is connected via wagmi, converts the wagmi
+ * walletClient into an ethers Signer via BrowserProvider.
+ */
+export declare function useWagmiEthersEnhancer(): EthersEnhancement;

package/dist/chains/useWagmiEthersEnhancer.js

@@ -0,0 +1,67 @@
+"use client";
+import {
+  __async
+} from "../chunk-MMUBH76A.js";
+import { useCallback, useContext, useEffect, useState } from "react";
+import { useStore } from "../provider/stores/useStore.js";
+import { getWagmiConfig } from "@getpara/evm-wallet-connectors";
+function walletClientToSigner(walletClient) {
+  return __async(this, null, function* () {
+    const { BrowserProvider } = yield import("ethers");
+    const provider = new BrowserProvider(walletClient.transport);
+    return provider.getSigner();
+  });
+}
+function useWagmiEthersEnhancer() {
+  var _a, _b;
+  const evmContext = useStore((state) => state.evmContext);
+  const evmCtxValue = useContext(evmContext);
+  const noopUseAccount = () => void 0;
+  const noopUseWalletClient = () => ({
+    data: void 0,
+    isLoading: false
+  });
+  const useEvmAccount = (_a = evmCtxValue == null ? void 0 : evmCtxValue.useAccount) != null ? _a : noopUseAccount;
+  const useEvmWalletClient = (_b = evmCtxValue == null ? void 0 : evmCtxValue.useWalletClient) != null ? _b : noopUseWalletClient;
+  const evmAccount = useEvmAccount();
+  const { data: evmWalletClient, isLoading: isWalletClientLoading } = useEvmWalletClient();
+  const externalAddress = evmAccount == null ? void 0 : evmAccount.address;
+  const isExternalConnected = !!externalAddress;
+  const [signer, setSigner] = useState(null);
+  const [isConverting, setIsConverting] = useState(false);
+  useEffect(() => {
+    if (!isExternalConnected || !evmWalletClient) {
+      setSigner(null);
+      return;
+    }
+    setIsConverting(true);
+    walletClientToSigner(evmWalletClient).then(setSigner).catch(() => setSigner(null)).finally(() => setIsConverting(false));
+  }, [isExternalConnected, evmWalletClient]);
+  const getSignerForAddress = useCallback((address) => __async(this, null, function* () {
+    try {
+      const config = getWagmiConfig();
+      if (!config) return null;
+      const { getConnectorClient } = yield import("@wagmi/core");
+      for (const connection of config.state.connections.values()) {
+        if (connection.accounts.some((a) => a.toLowerCase() === address.toLowerCase())) {
+          const client = yield getConnectorClient(config, {
+            connector: connection.connector,
+            account: address
+          });
+          return walletClientToSigner(client);
+        }
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }), []);
+  return {
+    signer: isExternalConnected ? signer : null,
+    isLoading: isExternalConnected && (isWalletClientLoading || isConverting),
+    getSignerForAddress
+  };
+}
+export {
+  useWagmiEthersEnhancer
+};

package/dist/chains/useWagmiViemEnhancer.d.ts

@@ -0,0 +1,7 @@
+import type { ViemEnhancement } from '@getpara/react-core/evm/viem';
+/**
+ * Wagmi-based enhancer for the chain hooks (useParaViemClient, useParaViemAccount).
+ * When an external EVM wallet is connected via wagmi, provides the walletClient
+ * so the viem hooks use it directly instead of creating a Para-backed client.
+ */
+export declare function useWagmiViemEnhancer(): ViemEnhancement;

package/dist/chains/useWagmiViemEnhancer.js

@@ -0,0 +1,56 @@
+"use client";
+import {
+  __async
+} from "../chunk-MMUBH76A.js";
+import { useCallback, useContext } from "react";
+import { useStore } from "../provider/stores/useStore.js";
+import { getWagmiConfig } from "@getpara/evm-wallet-connectors";
+import { createWalletClient, custom } from "viem";
+function useWagmiViemEnhancer() {
+  var _a, _b;
+  const evmContext = useStore((state) => state.evmContext);
+  const evmCtxValue = useContext(evmContext);
+  const noopUseAccount = () => void 0;
+  const noopUseWalletClient = () => ({
+    data: void 0,
+    isLoading: false
+  });
+  const useEvmAccount = (_a = evmCtxValue == null ? void 0 : evmCtxValue.useAccount) != null ? _a : noopUseAccount;
+  const useEvmWalletClient = (_b = evmCtxValue == null ? void 0 : evmCtxValue.useWalletClient) != null ? _b : noopUseWalletClient;
+  const evmAccount = useEvmAccount();
+  const { data: evmWalletClient, isLoading: isWalletClientLoading } = useEvmWalletClient();
+  const externalAddress = evmAccount == null ? void 0 : evmAccount.address;
+  const isExternalConnected = !!externalAddress;
+  const getWalletClientForAddress = useCallback((address) => __async(this, null, function* () {
+    try {
+      const config = getWagmiConfig();
+      if (!config) return null;
+      const { getConnectorClient } = yield import("@wagmi/core");
+      for (const connection of config.state.connections.values()) {
+        if (connection.accounts.some((a) => a.toLowerCase() === address.toLowerCase())) {
+          const connectorClient = yield getConnectorClient(config, {
+            connector: connection.connector,
+            account: address
+          });
+          return createWalletClient({
+            account: connectorClient.account,
+            chain: connectorClient.chain,
+            transport: custom(connectorClient.transport)
+          });
+        }
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }), []);
+  return {
+    address: isExternalConnected ? externalAddress : void 0,
+    walletClient: isExternalConnected ? evmWalletClient : null,
+    isLoading: isExternalConnected && isWalletClientLoading,
+    getWalletClientForAddress
+  };
+}
+export {
+  useWagmiViemEnhancer
+};