@getpara/cosmos-wallet-connectors 3.0.0 → 3.2.0

package/dist/providers/CosmosExternalWalletContext.js

@@ -26,10 +26,12 @@ import {
   defaultCosmosExternalWallet
 } from "@getpara/react-common";
 import { formatEthHexAddress } from "../utils/formatEthHexAddress.js";
+import { COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR, signCosmosWalletMessage } from "../utils/cosmosMessageSigning.js";
 import { externalHooks } from "./externalHooks.js";
 const CosmosExternalWalletContext = createContext(
   defaultCosmosExternalWallet
 );
+const normalizeWalletIdentifier = (identifier) => identifier == null ? void 0 : identifier.toLowerCase();
 function CosmosExternalWalletProvider({
   children,
   onSwitchWallet,
@@ -67,6 +69,53 @@ function CosmosExternalWalletProvider({
   const wasConnectedRef = useRef(isConnected);
   const disconnectionCallbackRef = useRef(null);
   const walletChangeCallbackRef = useRef(null);
+  const injectedWallets = useMemo(
+    () => WALLET_TYPES.filter((w) => !incompleteWallets.some((iw) => iw.grazType === w) && checkWallet(w)).map((w) => {
+      const wallet = grazGetWallet(w);
+      if (!wallet.eip6963ProviderInfo) {
+        return void 0;
+      }
+      const eipInfo = wallet.eip6963ProviderInfo;
+      return __spreadValues({
+        grazType: w,
+        // Using name here for the injected connector since that's the only common id across the networks
+        id: eipInfo.name,
+        internalId: eipInfo.name,
+        iconUrl: eipInfo.icon
+      }, eipInfo);
+    }).filter((w) => !!w),
+    [incompleteWallets]
+  );
+  const allWallets = useMemo(
+    () => [...incompleteWallets, ...injectedWallets],
+    [incompleteWallets, injectedWallets]
+  );
+  const getWallet = useCallback(
+    (walletType2) => allWallets.find((w) => w.grazType === walletType2 || w.grazMobileType === walletType2),
+    [allWallets]
+  );
+  const getProvider = useCallback(
+    (walletType2) => {
+      const wallet = getWallet(walletType2);
+      return {
+        provider: wallet == null ? void 0 : wallet.name,
+        providerId: wallet == null ? void 0 : wallet.id
+      };
+    },
+    [getWallet]
+  );
+  const getExternalWalletMetadata = useCallback(
+    (externalWallet) => {
+      const identifiers = [externalWallet.providerId, externalWallet.provider].map(normalizeWalletIdentifier);
+      return allWallets.find((wallet) => {
+        const walletIdentifiers = [wallet.id, wallet.internalId, wallet.name, wallet.grazType, wallet.grazMobileType].map(
+          normalizeWalletIdentifier
+        );
+        return identifiers.some((identifier) => identifier && walletIdentifiers.includes(identifier));
+      });
+    },
+    [allWallets]
+  );
   useEffect(() => {
     var _a2;
     if (walletChangeCallbackRef.current && (account == null ? void 0 : account[selectedChainId])) {
@@ -154,49 +203,63 @@ function CosmosExternalWalletProvider({
     });
     initializeConfig();
   }, [para.isSetup]);
-  const switchChain = (chainId) => __async(this, null, function* () {
-    var _a2;
-    let error;
-    let changeResp = {};
-    try {
-      let chainInfo;
-      if (shouldUseSuggestChainAndConnect) {
-        chainInfo = getChainInfo({ chainId });
-        if (!chainInfo) {
-          console.error("Chain not found.");
-          return;
+  const switchChain = useCallback(
+    (chainId) => __async(this, null, function* () {
+      var _a2;
+      let error;
+      let changeResp = {};
+      try {
+        let chainInfo;
+        if (shouldUseSuggestChainAndConnect) {
+          chainInfo = getChainInfo({ chainId });
+          if (!chainInfo) {
+            console.error("Chain not found.");
+            return;
+          }
+        }
+        const connectedWallet = yield shouldUseSuggestChainAndConnect ? suggestAndConnectAsync({ walletType, chainInfo }) : connectAsync({ walletType, chainId });
+        changeResp.address = connectedWallet.accounts[chainId].bech32Address;
+        changeResp.ethAddress = formatEthHexAddress(connectedWallet.accounts[chainId].address);
+      } catch (err) {
+        if (err.message === "No wallet exists") {
+          changeResp.error = err.message;
+        } else {
+          console.error("Graz connection error:", err);
+          changeResp.error = "An unknown error occurred.";
         }
       }
-      const connectedWallet = yield shouldUseSuggestChainAndConnect ? suggestAndConnectAsync({ walletType, chainInfo }) : connectAsync({ walletType, chainId });
-      changeResp.address = connectedWallet.accounts[chainId].bech32Address;
-      changeResp.ethAddress = formatEthHexAddress(connectedWallet.accounts[chainId].address);
-    } catch (err) {
-      if (err.message === "No wallet exists") {
-        changeResp.error = err.message;
-      } else {
-        console.error("Graz connection error:", err);
-        changeResp.error = "An unknown error occurred.";
+      onSwitchWallet(changeResp);
+      if (!changeResp.error) {
+        onSwitchChain(chainId);
+        const storedExternalWallet = para.externalWallets[(_a2 = changeResp.ethAddress) != null ? _a2 : ""];
+        const { provider, providerId } = getProvider(walletType);
+        para.setExternalWallet({
+          partnerId: para.partnerId,
+          address: changeResp.ethAddress,
+          type: "COSMOS",
+          provider,
+          providerId,
+          addressBech32: changeResp.address,
+          withFullParaAuth: storedExternalWallet.isExternalWithParaAuth,
+          withVerification: includeWalletVerification,
+          isConnectionOnly: connectionOnly
+        });
       }
-    }
-    onSwitchWallet(changeResp);
-    if (!changeResp.error) {
-      onSwitchChain(chainId);
-      const storedExternalWallet = para.externalWallets[(_a2 = changeResp.ethAddress) != null ? _a2 : ""];
-      const { provider, providerId } = getProvider(walletType);
-      para.setExternalWallet({
-        partnerId: para.partnerId,
-        address: changeResp.ethAddress,
-        type: "COSMOS",
-        provider,
-        providerId,
-        addressBech32: changeResp.address,
-        withFullParaAuth: storedExternalWallet.isExternalWithParaAuth,
-        withVerification: includeWalletVerification,
-        isConnectionOnly: connectionOnly
-      });
-    }
-    return { error };
-  });
+      return { error };
+    }),
+    [
+      connectAsync,
+      connectionOnly,
+      getProvider,
+      includeWalletVerification,
+      onSwitchChain,
+      onSwitchWallet,
+      para,
+      shouldUseSuggestChainAndConnect,
+      suggestAndConnectAsync,
+      walletType
+    ]
+  );
   const switchAccount = useCallback(
     (connectorName) => __async(this, null, function* () {
       const chainId = multiChain ? chains.map((c) => c.chainId) : selectedChainId;
@@ -205,187 +268,212 @@ function CosmosExternalWalletProvider({
         chainId
       });
     }),
-    [connectAsync]
+    [chains, connectAsync, multiChain, selectedChainId]
   );
-  const signMessageBase = (_0) => __async(this, [_0], function* ({
-    message,
-    wallet,
-    bech32Address,
-    ethAddress
-  }) {
-    const publicKey = (yield wallet.getKey(selectedChainId)).pubKey;
-    const signature = yield wallet.signArbitrary(selectedChainId, bech32Address, message);
-    return {
-      address: ethAddress,
-      addressBech32: bech32Address,
-      signature: signature.signature,
-      cosmosPublicKeyHex: Buffer.from(publicKey).toString("hex"),
-      cosmosSigner: bech32Address
-    };
-  });
-  const signMessage = (_0) => __async(this, [_0], function* ({ message, externalWallet }) {
-    let wallet, bech32Address, ethAddress;
-    if (externalWallet) {
-      const commonWallet = wallets.find((w) => w.id === externalWallet.providerId);
-      wallet = grazGetWallet(commonWallet == null ? void 0 : commonWallet.grazType);
-      bech32Address = externalWallet.addressBech32;
-      ethAddress = externalWallet.address;
-    } else {
-      wallet = grazGetWallet(walletType);
-      bech32Address = bech32AddressRef.current;
-      ethAddress = ethAddressRef.current;
-    }
-    if (!wallet) {
-      return { error: "Connected wallet not found" };
-    }
-    try {
-      return yield signMessageBase({
-        message,
+  const signMessageBase = useCallback(
+    (_0) => __async(this, [_0], function* ({
+      message,
+      wallet,
+      bech32Address,
+      ethAddress
+    }) {
+      if (!selectedChainId) {
+        throw new Error("No selected chain found");
+      }
+      const signedMessage = yield signCosmosWalletMessage({
+        chainId: selectedChainId,
         wallet,
         bech32Address,
-        ethAddress
+        message
       });
-    } catch (e) {
-      if (e.message.includes("Request rejected")) {
-        return { error: "Signature request rejected" };
+      return {
+        address: ethAddress,
+        addressBech32: bech32Address,
+        signature: signedMessage.signature,
+        cosmosPublicKeyHex: signedMessage.cosmosPublicKeyHex,
+        cosmosSigner: bech32Address
+      };
+    }),
+    [selectedChainId]
+  );
+  const signMessage = useCallback(
+    (_0) => __async(this, [_0], function* ({ message, externalWallet }) {
+      let wallet, bech32Address, ethAddress;
+      if (externalWallet) {
+        const commonWallet = getExternalWalletMetadata(externalWallet);
+        wallet = commonWallet ? grazGetWallet(commonWallet.grazType) : void 0;
+        bech32Address = externalWallet.addressBech32;
+        ethAddress = externalWallet.address;
+      } else {
+        wallet = grazGetWallet(walletType);
+        bech32Address = bech32AddressRef.current;
+        ethAddress = ethAddressRef.current;
       }
-      return { error: "An unknown error occurred" };
-    }
-  });
-  const connectBase = (walletType2, chainId) => __async(this, null, function* () {
-    var _a2, _b2;
-    if (!chainId) {
-      yield disconnectAsync();
-    }
-    const _chainId = chainId != null ? chainId : multiChain ? chains.map((c) => c.chainId) : selectedChainId;
-    if (!_chainId) {
-      throw new Error("Chain id not provided.");
-    }
-    if (!walletType2) {
-      throw new Error("Graz wallet type not provided.");
-    }
-    try {
-      const walletId = (_a2 = getWallet(walletType2)) == null ? void 0 : _a2.id;
-      const isFullAuthWallet = walletsWithFullAuth === "ALL" || walletsWithFullAuth.includes(walletId.toUpperCase());
-      let chainInfo;
-      if (shouldUseSuggestChainAndConnect) {
-        if (typeof _chainId !== "string") {
-          console.error("multiChain is not compatible with shouldUseSuggestChainAndConnect.");
-          return;
+      if (!wallet) {
+        return { error: "Connected wallet not found" };
+      }
+      if (!bech32Address || !ethAddress) {
+        return { error: "Connected wallet address not found" };
+      }
+      try {
+        return yield signMessageBase({
+          message,
+          wallet,
+          bech32Address,
+          ethAddress
+        });
+      } catch (e) {
+        if (e.message.includes("Request rejected")) {
+          return { error: "Signature request rejected" };
         }
-        chainInfo = getChainInfo({ chainId: _chainId });
-        if (!chainInfo) {
-          console.error("Chain not found.");
-          return;
+        if (e.message === COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR) {
+          return { error: e.message };
         }
+        return { error: "An unknown error occurred" };
       }
-      const connectedWallet = yield shouldUseSuggestChainAndConnect ? suggestAndConnectAsync({ walletType: walletType2, chainInfo }) : connectAsync({ walletType: walletType2, chainId: _chainId });
-      const firstChain = !chainId ? selectedChainId : typeof _chainId === "string" ? _chainId : _chainId[0];
-      const addressBech32 = connectedWallet.accounts[firstChain].bech32Address;
-      let rawAddress;
-      const accountAddress = connectedWallet.accounts[firstChain].address;
-      if (!accountAddress || accountAddress.length === 0 || accountAddress.byteLength === 0) {
-        const pubKey = connectedWallet.accounts[firstChain].pubKey;
-        rawAddress = rawSecp256k1PubkeyToRawAddress(pubKey);
-      } else {
-        rawAddress = accountAddress;
+    }),
+    [getExternalWalletMetadata, signMessageBase, walletType]
+  );
+  const connectBase = useCallback(
+    (walletType2, chainId) => __async(this, null, function* () {
+      var _a2, _b2;
+      if (!chainId) {
+        yield disconnectAsync();
       }
-      const address = formatEthHexAddress(rawAddress);
-      const { provider, providerId } = getProvider(walletType2);
-      return {
-        partnerId: para.partnerId,
-        type: "COSMOS",
-        address,
-        addressBech32,
-        provider,
-        providerId,
-        withFullParaAuth: isFullAuthWallet,
-        withVerification: includeWalletVerification,
-        isConnectionOnly: connectionOnly
-      };
-    } catch (e) {
-      let error;
-      if (e.message === "No wallet exists") {
-        error = e.message;
-      } else {
-        error = `Graz connection error: ${(_b2 = e == null ? void 0 : e.message) != null ? _b2 : e}`;
+      const _chainId = chainId != null ? chainId : multiChain ? chains.map((c) => c.chainId) : selectedChainId;
+      if (!_chainId) {
+        throw new Error("Chain id not provided.");
+      }
+      if (!walletType2) {
+        throw new Error("Graz wallet type not provided.");
       }
-      throw error;
-    }
-  });
-  const connectCallback = (walletType2) => {
-    return () => __async(this, null, function* () {
       try {
-        const _chainId = multiChain ? chains.map((c) => c.chainId) : selectedChainId;
-        const firstChain = typeof _chainId === "string" ? _chainId : _chainId[0];
-        const walletInfo = yield connectBase(walletType2, firstChain);
-        ethAddressRef.current = walletInfo.address;
-        bech32AddressRef.current = walletInfo.addressBech32;
-        return { externalWallet: walletInfo, chainId: firstChain };
+        const walletId = (_a2 = getWallet(walletType2)) == null ? void 0 : _a2.id;
+        const isFullAuthWallet = walletsWithFullAuth === "ALL" || walletsWithFullAuth.includes(walletId.toUpperCase());
+        let chainInfo;
+        if (shouldUseSuggestChainAndConnect) {
+          if (typeof _chainId !== "string") {
+            console.error("multiChain is not compatible with shouldUseSuggestChainAndConnect.");
+            return;
+          }
+          chainInfo = getChainInfo({ chainId: _chainId });
+          if (!chainInfo) {
+            console.error("Chain not found.");
+            return;
+          }
+        }
+        const connectedWallet = yield shouldUseSuggestChainAndConnect ? suggestAndConnectAsync({ walletType: walletType2, chainInfo }) : connectAsync({ walletType: walletType2, chainId: _chainId });
+        const firstChain = !chainId ? selectedChainId : typeof _chainId === "string" ? _chainId : _chainId[0];
+        const addressBech32 = connectedWallet.accounts[firstChain].bech32Address;
+        let rawAddress;
+        const accountAddress = connectedWallet.accounts[firstChain].address;
+        if (!accountAddress || accountAddress.length === 0 || accountAddress.byteLength === 0) {
+          const pubKey = connectedWallet.accounts[firstChain].pubKey;
+          rawAddress = rawSecp256k1PubkeyToRawAddress(pubKey);
+        } else {
+          rawAddress = accountAddress;
+        }
+        const address = formatEthHexAddress(rawAddress);
+        const { provider, providerId } = getProvider(walletType2);
+        return {
+          partnerId: para.partnerId,
+          type: "COSMOS",
+          address,
+          addressBech32,
+          provider,
+          providerId,
+          withFullParaAuth: isFullAuthWallet,
+          withVerification: includeWalletVerification,
+          isConnectionOnly: connectionOnly
+        };
       } catch (e) {
-        throw e;
+        let error;
+        if (e.message === "No wallet exists") {
+          error = e.message;
+        } else {
+          error = `Graz connection error: ${(_b2 = e == null ? void 0 : e.message) != null ? _b2 : e}`;
+        }
+        throw error;
       }
-    });
-  };
-  const connect = (walletType2) => __async(this, null, function* () {
-    var _a2, _b2;
-    updateExternalWalletState({ isConnecting: true });
-    try {
-      const authState = yield para.connectExternalWallet({
-        connect: connectCallback(walletType2)
+    }),
+    [
+      chains,
+      connectAsync,
+      connectionOnly,
+      disconnectAsync,
+      getProvider,
+      getWallet,
+      includeWalletVerification,
+      multiChain,
+      para.partnerId,
+      selectedChainId,
+      shouldUseSuggestChainAndConnect,
+      suggestAndConnectAsync,
+      walletsWithFullAuth
+    ]
+  );
+  const connectCallback = useCallback(
+    (walletType2) => {
+      return () => __async(this, null, function* () {
+        try {
+          const _chainId = multiChain ? chains.map((c) => c.chainId) : selectedChainId;
+          const firstChain = typeof _chainId === "string" ? _chainId : _chainId[0];
+          const walletInfo = yield connectBase(walletType2, firstChain);
+          ethAddressRef.current = walletInfo.address;
+          bech32AddressRef.current = walletInfo.addressBech32;
+          return { externalWallet: walletInfo, chainId: firstChain };
+        } catch (e) {
+          throw e;
+        }
       });
+    },
+    [chains, connectBase, multiChain, selectedChainId]
+  );
+  const connect = useCallback(
+    (walletType2) => __async(this, null, function* () {
+      var _a2, _b2;
+      updateExternalWalletState({ isConnecting: true });
+      try {
+        const authState = yield para.connectExternalWallet({
+          connect: connectCallback(walletType2)
+        });
+        return {
+          address: (_a2 = authState.externalWallet) == null ? void 0 : _a2.address,
+          authState
+        };
+      } catch (e) {
+        return {
+          error: (_b2 = e == null ? void 0 : e.message) != null ? _b2 : e
+        };
+      } finally {
+        updateExternalWalletState({ isConnecting: false });
+      }
+    }),
+    [connectCallback, para, updateExternalWalletState]
+  );
+  const wallets = useMemo(
+    () => allWallets.map((wallet) => {
+      return __spreadProps(__spreadValues({
+        connect: () => connect(wallet.grazType),
+        connectMobile: () => connect(wallet.grazType),
+        type: "COSMOS"
+      }, wallet), {
+        // Using name here since that's the only common id across the networks
+        id: wallet.name,
+        installed: checkWallet(wallet.grazType)
+      });
+    }).filter((w) => !!w),
+    [allWallets, connect]
+  );
+  const formattedChains = useMemo(
+    () => chains.map((c) => {
       return {
-        address: (_a2 = authState.externalWallet) == null ? void 0 : _a2.address,
-        authState
-      };
-    } catch (e) {
-      return {
-        error: (_b2 = e == null ? void 0 : e.message) != null ? _b2 : e
+        id: c.chainId,
+        name: c.chainName
       };
-    } finally {
-      updateExternalWalletState({ isConnecting: false });
-    }
-  });
-  const injectedWallets = WALLET_TYPES.filter((w) => !incompleteWallets.some((iw) => iw.grazType === w) && checkWallet(w)).map((w) => {
-    const wallet = grazGetWallet(w);
-    if (!wallet.eip6963ProviderInfo) {
-      return void 0;
-    }
-    const eipInfo = wallet.eip6963ProviderInfo;
-    return __spreadValues({
-      grazType: w,
-      // Using name here for the injected connector since that's the only common id across the networks
-      id: eipInfo.name,
-      internalId: eipInfo.name,
-      iconUrl: eipInfo.icon
-    }, eipInfo);
-  }).filter((w) => !!w);
-  const allWallets = [...incompleteWallets, ...injectedWallets];
-  const getWallet = (walletType2) => allWallets.find((w) => w.grazType === walletType2 || w.grazMobileType === walletType2);
-  const getProvider = (walletType2) => {
-    const wallet = getWallet(walletType2);
-    return {
-      provider: wallet == null ? void 0 : wallet.name,
-      providerId: wallet == null ? void 0 : wallet.id
-    };
-  };
-  const wallets = allWallets.map((wallet) => {
-    return __spreadProps(__spreadValues({
-      connect: () => connect(wallet.grazType),
-      connectMobile: () => connect(wallet.grazType),
-      type: "COSMOS"
-    }, wallet), {
-      // Using name here since that's the only common id across the networks
-      id: wallet.name,
-      installed: checkWallet(wallet.grazType)
-    });
-  }).filter((w) => !!w);
-  const formattedChains = chains.map((c) => {
-    return {
-      id: c.chainId,
-      name: c.chainName
-    };
-  });
+    }),
+    [chains]
+  );
   const connectParaEmbedded = useCallback(() => __async(this, null, function* () {
     if (!para) {
       return { error: "No para instance available" };
@@ -398,72 +486,74 @@ function CosmosExternalWalletProvider({
       const error = err instanceof Error ? err.message : "Unknown error";
       return { error };
     }
-  }), [para, multiChain, chains, selectedChainId]);
-  const requestInfo = (providerId) => __async(this, null, function* () {
-    var _a2;
-    const wallet = wallets.find((w) => w.id === providerId);
-    if (!wallet) {
-      throw new Error(`Wallet for provider ${providerId} not found`);
-    }
-    disconnectTypeRef.current = "ACCOUNT_LINKING";
-    try {
-      const externalWallet = yield connectBase(
-        wallet.grazType,
-        multiChain ? chains.map((c) => c.chainId) : selectedChainId
-      );
-      return externalWallet;
-    } catch (e) {
-      console.error("Error linking account:", e);
-      throw new Error((_a2 = e == null ? void 0 : e.message) != null ? _a2 : e);
-    }
-  });
-  const disconnectBase = (_0, ..._1) => __async(this, [_0, ..._1], function* (_, { disconnectType } = {}) {
-    var _a2;
-    if (disconnectType) {
-      disconnectTypeRef.current = disconnectType;
-    }
-    try {
-      yield disconnectAsync();
-    } catch (e) {
-      console.error("Error linking account:", e);
-      throw new Error((_a2 = e == null ? void 0 : e.message) != null ? _a2 : e);
-    } finally {
-      disconnectTypeRef.current = void 0;
-    }
-  });
-  return /* @__PURE__ */ jsx(
-    CosmosExternalWalletContext.Provider,
-    {
-      value: useMemo(
-        () => __spreadValues({
-          wallets,
-          chains: formattedChains,
-          chainId: selectedChainId,
-          disconnect: disconnectAsync,
-          disconnectStatus,
-          switchChain,
-          switchConnection: switchAccount,
-          connectParaEmbedded,
-          signMessage,
-          requestInfo,
-          disconnectBase
-        }, externalHooks),
-        [
-          wallets,
-          formattedChains,
-          selectedChainId,
-          disconnectAsync,
-          switchChain,
-          switchAccount,
-          connectParaEmbedded,
-          signMessage,
-          requestInfo,
-          disconnectBase
-        ]
-      ),
-      children
-    }
+  }), [chains, connectAsync, multiChain, para, selectedChainId]);
+  const requestInfo = useCallback(
+    (providerId) => __async(this, null, function* () {
+      var _a2;
+      const wallet = wallets.find((w) => w.id === providerId);
+      if (!wallet) {
+        throw new Error(`Wallet for provider ${providerId} not found`);
+      }
+      disconnectTypeRef.current = "ACCOUNT_LINKING";
+      try {
+        const externalWallet = yield connectBase(
+          wallet.grazType,
+          multiChain ? chains.map((c) => c.chainId) : selectedChainId
+        );
+        return externalWallet;
+      } catch (e) {
+        console.error("Error linking account:", e);
+        throw new Error((_a2 = e == null ? void 0 : e.message) != null ? _a2 : e);
+      }
+    }),
+    [chains, connectBase, multiChain, selectedChainId, wallets]
+  );
+  const disconnectBase = useCallback(
+    (_0, ..._1) => __async(this, [_0, ..._1], function* (_, { disconnectType } = {}) {
+      var _a2;
+      if (disconnectType) {
+        disconnectTypeRef.current = disconnectType;
+      }
+      try {
+        yield disconnectAsync();
+      } catch (e) {
+        console.error("Error linking account:", e);
+        throw new Error((_a2 = e == null ? void 0 : e.message) != null ? _a2 : e);
+      } finally {
+        disconnectTypeRef.current = void 0;
+      }
+    }),
+    [disconnectAsync]
+  );
+  const contextValue = useMemo(
+    () => __spreadValues({
+      wallets,
+      chains: formattedChains,
+      chainId: selectedChainId,
+      disconnect: disconnectAsync,
+      disconnectStatus,
+      switchChain,
+      switchConnection: switchAccount,
+      connectParaEmbedded,
+      signMessage,
+      requestInfo,
+      disconnectBase
+    }, externalHooks),
+    [
+      wallets,
+      formattedChains,
+      selectedChainId,
+      disconnectAsync,
+      disconnectStatus,
+      switchChain,
+      switchAccount,
+      connectParaEmbedded,
+      signMessage,
+      requestInfo,
+      disconnectBase
+    ]
   );
+  return /* @__PURE__ */ jsx(CosmosExternalWalletContext.Provider, { value: contextValue, children });
 }
 export {
   CosmosExternalWalletContext,

package/dist/utils/cosmosMessageSigning.d.ts

@@ -0,0 +1,18 @@
+import type { Wallet } from 'graz';
+type CosmosAdr36SignDoc = Parameters<Wallet['signAmino']>[2];
+type SignCosmosWalletMessageArgs = {
+    chainId: string;
+    wallet: Wallet;
+    bech32Address: string;
+    message: string;
+};
+export declare const COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR = "Cosmos wallet does not support signArbitrary or signAmino";
+export declare function createCosmosAdr36SignDoc({ signer, message }: {
+    signer: string;
+    message: string;
+}): CosmosAdr36SignDoc;
+export declare function signCosmosWalletMessage({ chainId, wallet, bech32Address, message, }: SignCosmosWalletMessageArgs): Promise<{
+    signature: string;
+    cosmosPublicKeyHex: string;
+}>;
+export {};

package/dist/utils/cosmosMessageSigning.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  __async
+} from "../chunk-IV3L3JVM.js";
+const COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR = "Cosmos wallet does not support signArbitrary or signAmino";
+function createCosmosAdr36SignDoc({ signer, message }) {
+  return {
+    chain_id: "",
+    account_number: "0",
+    sequence: "0",
+    fee: { gas: "0", amount: [] },
+    msgs: [
+      {
+        type: "sign/MsgSignData",
+        value: {
+          signer,
+          data: Buffer.from(message).toString("base64")
+        }
+      }
+    ],
+    memo: ""
+  };
+}
+function signCosmosWalletMessage(_0) {
+  return __async(this, arguments, function* ({
+    chainId,
+    wallet,
+    bech32Address,
+    message
+  }) {
+    var _a;
+    const signed = yield signWithWallet({ chainId, wallet, bech32Address, message });
+    const signature = signed.signature;
+    if (!signature) {
+      throw new Error("Cosmos wallet did not return a signature");
+    }
+    return {
+      signature,
+      cosmosPublicKeyHex: (_a = getSignaturePublicKeyHex(signed)) != null ? _a : yield getWalletPublicKeyHex(wallet, chainId)
+    };
+  });
+}
+function signWithWallet(_0) {
+  return __async(this, arguments, function* ({
+    chainId,
+    wallet,
+    bech32Address,
+    message
+  }) {
+    if (wallet.signArbitrary) {
+      return wallet.signArbitrary(chainId, bech32Address, message);
+    }
+    if (!wallet.signAmino) {
+      throw new Error(COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR);
+    }
+    const response = yield wallet.signAmino(
+      chainId,
+      bech32Address,
+      createCosmosAdr36SignDoc({ signer: bech32Address, message })
+    );
+    return response.signature;
+  });
+}
+function getSignaturePublicKeyHex(signature) {
+  var _a;
+  const publicKey = (_a = signature.pub_key) == null ? void 0 : _a.value;
+  if (!publicKey) {
+    return void 0;
+  }
+  return Buffer.from(publicKey, "base64").toString("hex");
+}
+function getWalletPublicKeyHex(wallet, chainId) {
+  return __async(this, null, function* () {
+    const publicKey = (yield wallet.getKey(chainId)).pubKey;
+    return Buffer.from(publicKey).toString("hex");
+  });
+}
+export {
+  COSMOS_WALLET_SIGNING_UNSUPPORTED_ERROR,
+  createCosmosAdr36SignDoc,
+  signCosmosWalletMessage
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@getpara/cosmos-wallet-connectors",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "dependencies": {
-    "@getpara/graz-connector": "3.0.0",
-    "@getpara/react-common": "3.0.0",
-    "@getpara/web-sdk": "3.0.0",
+    "@getpara/graz-connector": "3.2.0",
+    "@getpara/react-common": "3.2.0",
+    "@getpara/web-sdk": "3.2.0",
     "@leapwallet/cosmos-social-login-capsule-provider": "^0.0.41",
     "zustand": "^4.5.2",
     "zustand-sync-tabs": "^0.2.2"
@@ -23,7 +23,7 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "e6c42e42adfcfadb0114b1ac65ba5203e6274712",
+  "gitHead": "096152f48e9d9a64fdb192588315c64d33d15a1b",
   "main": "dist/index.js",
   "peerDependencies": {
     "graz": ">=0.4.1",