graz 0.0.45-alpha.2 → 0.1.0-alpha.2

package/dist/index.js

@@ -907,14 +907,20 @@ __export(src_exports, {
   connect: () => connect,
   connectClient: () => connectClient,
   connectSigningClient: () => connectSigningClient,
+  convertDenomToMicroDenom: () => convertDenomToMicroDenom,
+  convertFromMicroDenom: () => convertFromMicroDenom,
+  convertMicroDenomToDenom: () => convertMicroDenomToDenom,
+  convertToFixedDecimals: () => convertToFixedDecimals,
   defineChain: () => defineChain,
   defineChainInfo: () => defineChainInfo,
   defineChains: () => defineChains,
   disconnect: () => disconnect,
   executeContract: () => executeContract,
+  formatTokenName: () => formatTokenName,
+  getAllBalance: () => getAllBalance,
   getAvailableWallets: () => getAvailableWallets,
+  getBalance: () => getBalance,
   getBalanceStaked: () => getBalanceStaked,
-  getBalances: () => getBalances,
   getCosmostation: () => getCosmostation,
   getKeplr: () => getKeplr,
   getLeap: () => getLeap,
@@ -928,6 +934,7 @@ __export(src_exports, {
   getWCLeap: () => getWCLeap,
   getWallet: () => getWallet,
   getWalletConnect: () => getWalletConnect,
+  handleNaN: () => handleNaN,
   instantiateContract: () => instantiateContract,
   mainnetChains: () => mainnetChains,
   mainnetChainsArray: () => mainnetChainsArray,
@@ -938,19 +945,28 @@ __export(src_exports, {
   suggestChainAndConnect: () => suggestChainAndConnect,
   testnetChains: () => testnetChains,
   testnetChainsArray: () => testnetChainsArray,
+  truncate: () => truncate,
   useAccount: () => useAccount,
   useActiveChainValidators: () => useActiveChainValidators,
   useActiveWalletType: () => useActiveWalletType,
+  useAllBalances: () => useAllBalances,
+  useBalance: () => useBalance,
   useBalanceStaked: () => useBalanceStaked,
-  useBalances: () => useBalances,
+  useChain: () => useChain,
+  useChainBalances: () => useChainBalances,
   useCheckWallet: () => useCheckWallet,
   useConnect: () => useConnect,
   useConnectClient: () => useConnectClient,
   useConnectSigningClient: () => useConnectSigningClient,
   useDisconnect: () => useDisconnect,
+  useExecuteContract: () => useExecuteContract,
   useGrazEvents: () => useGrazEvents,
+  useInstantiateContract: () => useInstantiateContract,
   useOfflineSigners: () => useOfflineSigners,
+  useQueryRaw: () => useQueryRaw,
+  useQuerySmart: () => useQuerySmart,
   useRecentChain: () => useRecentChain,
+  useSendIbcTokens: () => useSendIbcTokens,
   useSendTokens: () => useSendTokens,
   useSuggestChain: () => useSuggestChain,
   useSuggestChainAndConnect: () => useSuggestChainAndConnect
@@ -1963,16 +1979,19 @@ var configureGraz = (args) => {
 };
 
 // src/actions/methods.ts
-var getBalances = async ({
+var getAllBalance = async ({
+  bech32Address,
+  client
+}) => {
+  const balances = await client.getAllBalances(bech32Address);
+  return balances;
+};
+var getBalance = async ({
   bech32Address,
   client,
-  currencies: currencies9
+  searchDenom
 }) => {
-  const balances = await Promise.all(
-    currencies9.filter((i) => !i.coinMinimalDenom.startsWith("cw20:")).map(async (item) => {
-      return client.getBalance(bech32Address, item.coinMinimalDenom);
-    })
-  );
+  const balances = await client.getBalance(bech32Address, searchDenom);
   return balances;
 };
 var getBalanceStaked = async ({
@@ -2488,39 +2507,18 @@ var useDisconnect = ({ onError, onLoading, onSuccess } = {}) => {
 };
 var useOfflineSigners = (args) => {
   const accounts = useAccount();
-  const { data } = (0, import_react_query2.useQuery)(
-    ["OFFLINE_SIGNERS", { accounts }],
-    async () => {
-      if (!accounts)
-        return void 0;
-      const connectedChainIds = Object.values(accounts).map((i) => i == null ? void 0 : i.chainId).filter(Boolean);
-      const res = {};
-      await Promise.all(
-        connectedChainIds.map(async (_chainId) => {
-          const signers = await getOfflineSigners({
-            chainId: _chainId
-          });
-          res[_chainId] = signers;
-        })
-      );
-      return res;
-    },
-    {
-      enabled: Boolean(accounts)
-    }
-  );
   const query = (0, import_react_query2.useQuery)(
     [
       "USE_OFFLINE_SIGNERS",
       {
         args,
-        offlineSigners: data
+        accounts
       }
     ],
     async () => {
-      if (!data)
+      if (!accounts)
         return void 0;
-      const connectedChainIds = Object.keys(data).map(([chainId]) => chainId).filter((i) => i);
+      const connectedChainIds = Object.keys(accounts).map(([chainId]) => chainId).filter(Boolean);
       if (args == null ? void 0 : args.chainId) {
         const offlineSigners = await getOfflineSigners({
           chainId: args.chainId
@@ -2538,7 +2536,7 @@ var useOfflineSigners = (args) => {
       );
       return res;
     },
-    { enabled: Boolean(data), refetchOnMount: false, refetchOnWindowFocus: false }
+    { enabled: Boolean(accounts), refetchOnMount: false, refetchOnWindowFocus: false }
   );
   return query;
 };
@@ -2596,6 +2594,27 @@ var useSuggestChainAndConnect = ({ onError, onLoading, onSuccess } = {}) => {
     suggestAndConnectAsync: mutation.mutateAsync
   };
 };
+var useChain = ({ chainId }) => {
+  const chains = useGrazInternalStore((x) => x.chains);
+  const chain = chains == null ? void 0 : chains.find((x) => x.chainId === chainId);
+  if (!chain)
+    return;
+  const currencies9 = chain.currencies;
+  const convertMinimalDenomToDenom = (searchMinimalDenom, value) => {
+    const currency = chain.currencies.find((x) => x.coinMinimalDenom === searchMinimalDenom);
+    if (!currency)
+      return;
+    return {
+      denom: currency.coinDenom,
+      value: Number(value) * Math.pow(10, currency.coinDecimals)
+    };
+  };
+  return {
+    convertMinimalDenomToDenom,
+    currencies: currencies9,
+    data: chain
+  };
+};
 
 // src/hooks/clients.ts
 var import_stargate2 = require("@cosmjs/stargate");
@@ -2610,7 +2629,7 @@ var useConnectClient = (args) => {
   const chains = (args == null ? void 0 : args.onlyConnectedChains) ? sessionChains : _chains;
   const query = (0, import_react_query4.useQuery)(
     [
-      "USE_CLIENTS",
+      "USE_CONNECT_CLIENT",
       {
         client: _client,
         chainId: args == null ? void 0 : args.chainId,
@@ -2657,7 +2676,7 @@ var useConnectSigningClient = (args) => {
   const singleChain = _chains == null ? void 0 : _chains.find((i) => i.chainId === (args == null ? void 0 : args.chainId));
   const sessionChains = sessionChainIds == null ? void 0 : sessionChainIds.map((i) => _chains.find((x) => x.chainId === i));
   const queryKey = [
-    "USE_SIGNING_CLIENTS",
+    "USE_CONNECT_SIGNING_CLIENT",
     { client: _client, chainId: args == null ? void 0 : args.chainId, options: args == null ? void 0 : args.options }
   ];
   const query = (0, import_react_query4.useQuery)(
@@ -2719,21 +2738,57 @@ var useConnectSigningClient = (args) => {
 // src/hooks/methods.ts
 var import_encoding2 = require("@cosmjs/encoding");
 var import_react_query5 = require("@tanstack/react-query");
-var useBalances = (args) => {
-  const _client = args.client ?? useGrazInternalStore.getState().defaultClient;
+var useBalance = (args) => {
+  const _chains = useGrazInternalStore.getState().chains;
+  const chain = _chains == null ? void 0 : _chains.find((i) => i.chainId === args.chainId);
+  const { data: client } = useConnectClient({
+    client: "stargate",
+    chainId: args.chainId,
+    enabled: Boolean(chain) && Boolean(args.bech32Address)
+  });
+  const query = (0, import_react_query5.useQuery)(
+    [
+      "USE_BALANCE",
+      {
+        client,
+        ...args,
+        _chains
+      }
+    ],
+    async () => {
+      if (client) {
+        const res = await getBalance({
+          client,
+          bech32Address: (0, import_encoding2.toBech32)(chain.bech32Config.bech32PrefixAccAddr, (0, import_encoding2.fromBech32)(args.bech32Address).data),
+          searchDenom: args.searchDenom
+        });
+        return res;
+      }
+      return void 0;
+    },
+    {
+      enabled: Boolean(args.bech32Address) && Boolean(chain) && (Boolean(client) || Boolean(args.searchDenom)),
+      refetchOnMount: false,
+      refetchOnReconnect: true,
+      refetchOnWindowFocus: false
+    }
+  );
+  return query;
+};
+var useAllBalances = (args) => {
   const _chains = useGrazInternalStore.getState().chains;
   const { data: singleClient } = useConnectClient({
-    client: _client,
+    client: "stargate",
     chainId: args.chainId,
-    enabled: Boolean(args.chainId)
+    enabled: Boolean(args.chainId) && Boolean(args.bech32Address)
   });
   const { data: multiClient } = useConnectClient({
-    client: _client,
-    enabled: !args.chainId
+    client: "stargate",
+    enabled: !args.chainId && Boolean(args.bech32Address)
   });
   const query = (0, import_react_query5.useQuery)(
     [
-      "USE_BALANCES",
+      "USE_ALL_BALANCES",
       {
         singleClient,
         multiClient,
@@ -2744,10 +2799,9 @@ var useBalances = (args) => {
     async () => {
       if (args.chainId && singleClient) {
         const singleChain = _chains == null ? void 0 : _chains.find((i) => i.chainId === args.chainId);
-        const res = await getBalances({
+        const res = await getAllBalance({
           client: singleClient,
-          bech32Address: (0, import_encoding2.toBech32)(singleChain.bech32Config.bech32PrefixAccAddr, (0, import_encoding2.fromBech32)(args.bech32Address).data),
-          currencies: singleChain.currencies
+          bech32Address: (0, import_encoding2.toBech32)(singleChain.bech32Config.bech32PrefixAccAddr, (0, import_encoding2.fromBech32)(args.bech32Address).data)
         });
         return res;
       }
@@ -2759,10 +2813,9 @@ var useBalances = (args) => {
             const chain = _chains == null ? void 0 : _chains.find((i) => i.chainId === chainId);
             if (!chain)
               return;
-            const _res = await getBalances({
+            const _res = await getAllBalance({
               client,
-              bech32Address: (0, import_encoding2.toBech32)(chain.bech32Config.bech32PrefixAccAddr, (0, import_encoding2.fromBech32)(args.bech32Address).data),
-              currencies: chain.currencies
+              bech32Address: (0, import_encoding2.toBech32)(chain.bech32Config.bech32PrefixAccAddr, (0, import_encoding2.fromBech32)(args.bech32Address).data)
             });
             res[chainId] = _res;
           })
@@ -2780,20 +2833,95 @@ var useBalances = (args) => {
   );
   return query;
 };
+var useChainBalances = (args) => {
+  const _client = args.client ?? useGrazInternalStore.getState().defaultClient;
+  const _chains = useGrazInternalStore.getState().chains;
+  const { data: singleClient } = useConnectClient({
+    client: _client,
+    chainId: args.chainId,
+    enabled: Boolean(args.chainId) && Boolean(args.bech32Address)
+  });
+  const { data: multiClient } = useConnectClient({
+    client: _client,
+    enabled: !args.chainId && Boolean(args.bech32Address)
+  });
+  const query = (0, import_react_query5.useQuery)(
+    [
+      "USE_CHAIN_BALANCES",
+      {
+        singleClient,
+        multiClient,
+        ...args,
+        _chains
+      }
+    ],
+    async () => {
+      if (args.chainId && singleClient) {
+        const singleChain = _chains == null ? void 0 : _chains.find((i) => i.chainId === args.chainId);
+        const res = await Promise.all(
+          singleChain.currencies.map(
+            (currency) => getBalance({
+              client: singleClient,
+              bech32Address: (0, import_encoding2.toBech32)(
+                singleChain.bech32Config.bech32PrefixAccAddr,
+                (0, import_encoding2.fromBech32)(args.bech32Address).data
+              ),
+              searchDenom: currency.coinMinimalDenom
+            })
+          )
+        );
+        return res;
+      }
+      if (!args.chainId && multiClient) {
+        const multiChain = Object.entries(multiClient);
+        const res = {};
+        await Promise.all(
+          multiChain.map(async ([chainId, client]) => {
+            const chain = _chains == null ? void 0 : _chains.find((i) => i.chainId === chainId);
+            if (!chain)
+              return;
+            const _res = await Promise.all(
+              chain.currencies.filter((i) => !i.coinMinimalDenom.startsWith("cw20:")).map(
+                (currency) => getBalance({
+                  client,
+                  bech32Address: (0, import_encoding2.toBech32)(
+                    chain.bech32Config.bech32PrefixAccAddr,
+                    (0, import_encoding2.fromBech32)(args.bech32Address).data
+                  ),
+                  searchDenom: currency.coinMinimalDenom
+                })
+              )
+            );
+            res[chainId] = _res;
+          })
+        );
+        return res;
+      }
+      return void 0;
+    },
+    {
+      enabled: Boolean(args.bech32Address) && Boolean(_chains) && (Boolean(singleClient) || Boolean(multiClient)),
+      refetchOnMount: false,
+      refetchOnReconnect: true,
+      refetchOnWindowFocus: false
+    }
+  );
+  return query;
+};
 var useBalanceStaked = (args) => {
   const _chains = useGrazInternalStore.getState().chains;
   const { data: singleClient } = useConnectClient({
     client: "stargate",
     chainId: args.chainId,
-    enabled: Boolean(args.chainId)
+    enabled: Boolean(args.chainId) && Boolean(args.bech32Address)
   });
   const { data: multiClient } = useConnectClient({
     client: "stargate",
-    enabled: !args.chainId
+    enabled: !args.chainId && Boolean(args.bech32Address)
   });
   const query = (0, import_react_query5.useQuery)(
     [
-      "USE_BALANCE_STAKED",
+      "useBalanceStaked",
       {
         singleClient,
         multiClient,
@@ -2878,6 +3006,188 @@ var useSendTokens = ({
     status: mutation.status
   };
 };
+var useSendIbcTokens = ({
+  chainId,
+  signingClientOptions,
+  onError,
+  onLoading,
+  onSuccess
+}) => {
+  const { data: _signingClient } = useConnectSigningClient({
+    chainId,
+    client: "stargate",
+    options: signingClientOptions
+  });
+  const queryKey = [
+    "USE_SEND_IBC_TOKENS",
+    { onError, onLoading, onSuccess, _signingClient, chainId, signingClientOptions }
+  ];
+  const mutation = (0, import_react_query5.useMutation)(
+    queryKey,
+    async (args) => {
+      if (!_signingClient)
+        throw new Error("Signing client is not available");
+      const res = await sendIbcTokens({ signingClient: _signingClient, ...args });
+      return res;
+    },
+    {
+      onError: (err, data) => Promise.resolve(onError == null ? void 0 : onError(err, data)),
+      onMutate: onLoading,
+      onSuccess: (txResponse) => Promise.resolve(onSuccess == null ? void 0 : onSuccess(txResponse))
+    }
+  );
+  return {
+    error: mutation.error,
+    isLoading: mutation.isLoading,
+    isSuccess: mutation.isSuccess,
+    sendIbcTokens: mutation.mutate,
+    sendIbcTokensAsync: mutation.mutateAsync,
+    status: mutation.status
+  };
+};
+var useInstantiateContract = ({
+  chainId,
+  codeId,
+  signingClientOptions,
+  onError,
+  onLoading,
+  onSuccess
+}) => {
+  var _a;
+  const account = useAccount({
+    chainId
+  });
+  const accountAddress = (_a = account == null ? void 0 : account.account) == null ? void 0 : _a.bech32Address;
+  const { data: _signingClient } = useConnectSigningClient({
+    chainId,
+    client: "cosmWasm",
+    options: signingClientOptions
+  });
+  const mutationFn = (args) => {
+    if (!accountAddress)
+      throw new Error("senderAddress is undefined");
+    if (!_signingClient)
+      throw new Error("Signing client is not available");
+    return instantiateContract({
+      ...args,
+      signingClient: _signingClient,
+      fee: args.fee ?? "auto",
+      senderAddress: accountAddress,
+      codeId
+    });
+  };
+  const queryKey = ["USE_INSTANTIATE_CONTRACT", onError, onLoading, onSuccess, codeId, accountAddress];
+  const mutation = (0, import_react_query5.useMutation)(queryKey, mutationFn, {
+    onError: (err, data) => Promise.resolve(onError == null ? void 0 : onError(err, data)),
+    onMutate: onLoading,
+    onSuccess: (instantiateResult) => Promise.resolve(onSuccess == null ? void 0 : onSuccess(instantiateResult))
+  });
+  return {
+    error: mutation.error,
+    isLoading: mutation.isLoading,
+    isSuccess: mutation.isSuccess,
+    instantiateContract: mutation.mutate,
+    instantiateContractAsync: mutation.mutateAsync,
+    status: mutation.status
+  };
+};
+var useExecuteContract = ({
+  chainId,
+  contractAddress,
+  signingClientOptions,
+  onError,
+  onLoading,
+  onSuccess
+}) => {
+  var _a;
+  const account = useAccount({
+    chainId
+  });
+  const accountAddress = (_a = account == null ? void 0 : account.account) == null ? void 0 : _a.bech32Address;
+  const { data: _signingClient } = useConnectSigningClient({
+    chainId,
+    client: "cosmWasm",
+    options: signingClientOptions
+  });
+  const mutationFn = (args) => {
+    if (!accountAddress)
+      throw new Error("senderAddress is undefined");
+    if (!_signingClient)
+      throw new Error("Signing client is not available");
+    return executeContract({
+      ...args,
+      signingClient: _signingClient,
+      fee: args.fee ?? "auto",
+      senderAddress: accountAddress,
+      contractAddress,
+      memo: args.memo ?? "",
+      funds: args.funds ?? []
+    });
+  };
+  const queryKey = ["USE_EXECUTE_CONTRACT", onError, onLoading, onSuccess, contractAddress, accountAddress];
+  const mutation = (0, import_react_query5.useMutation)(queryKey, mutationFn, {
+    onError: (err, data) => Promise.resolve(onError == null ? void 0 : onError(err, data)),
+    onMutate: onLoading,
+    onSuccess: (executeResult) => Promise.resolve(onSuccess == null ? void 0 : onSuccess(executeResult))
+  });
+  return {
+    error: mutation.error,
+    isLoading: mutation.isLoading,
+    isSuccess: mutation.isSuccess,
+    executeContract: mutation.mutate,
+    executeContractAsync: mutation.mutateAsync,
+    status: mutation.status
+  };
+};
+var useQuerySmart = ({
+  address,
+  queryMsg,
+  chainId
+}) => {
+  const { data: client } = useConnectClient({
+    client: "cosmWasm",
+    chainId
+  });
+  const query = (0, import_react_query5.useQuery)(
+    ["USE_QUERY_SMART", { address, queryMsg, chainId }],
+    () => {
+      if (!address || !queryMsg)
+        throw new Error("address or queryMsg undefined");
+      if (!client)
+        throw new Error("Client is not available");
+      return getQuerySmart({ address, queryMsg, client });
+    },
+    {
+      enabled: Boolean(address) && Boolean(queryMsg)
+    }
+  );
+  return query;
+};
+var useQueryRaw = ({
+  address,
+  key,
+  chainId
+}) => {
+  const { data: client } = useConnectClient({
+    client: "cosmWasm",
+    chainId
+  });
+  const queryKey = ["USE_QUERY_RAW", key, address];
+  const query = (0, import_react_query5.useQuery)(
+    queryKey,
+    ({ queryKey: [, _address] }) => {
+      if (!address || !key)
+        throw new Error("address or key undefined");
+      if (!client)
+        throw new Error("Client is not available");
+      return getQueryRaw({ address, keyStr: key, client });
+    },
+    {
+      enabled: Boolean(address) && Boolean(key)
+    }
+  );
+  return query;
+};
 
 // src/provider/events.tsx
 var import_react2 = require("react");
@@ -2965,6 +3275,43 @@ var GrazProvider = ({ children, grazConfig, ...props }) => {
     children
   ] }) }, "graz-provider");
 };
+
+// src/utils/conversion.ts
+var convertMicroDenomToDenom = (value, decimals) => {
+  if (decimals === 0) {
+    return Number(value);
+  }
+  return handleNaN(Number(value) / Math.pow(10, decimals));
+};
+var convertDenomToMicroDenom = (value, decimals) => {
+  if (decimals === 0) {
+    return Number(value);
+  }
+  return handleNaN(parseInt(String(Number(value) * Math.pow(10, decimals)), 10));
+};
+var convertFromMicroDenom = (denom) => {
+  return denom.substring(1).toUpperCase();
+};
+var convertToFixedDecimals = (value, fractionDigits = 2) => {
+  const amount = Number(value);
+  return amount > 0.01 ? amount.toFixed(fractionDigits) : String(amount);
+};
+var formatTokenName = (name) => {
+  if (name) {
+    return name.slice(0, 1).toUpperCase() + name.slice(1).toLowerCase();
+  }
+  return "";
+};
+var handleNaN = (value) => {
+  return isNaN(value) ? 0 : value;
+};
+var truncate = (string, slice) => {
+  if (string && slice && string.length <= slice)
+    return string;
+  const pre = string == null ? void 0 : string.slice(0, slice || 8);
+  const post = string == null ? void 0 : string.slice((slice || 8) * -1);
+  return `${pre}...${post}`;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GrazEvents,
@@ -2977,14 +3324,20 @@ var GrazProvider = ({ children, grazConfig, ...props }) => {
   connect,
   connectClient,
   connectSigningClient,
+  convertDenomToMicroDenom,
+  convertFromMicroDenom,
+  convertMicroDenomToDenom,
+  convertToFixedDecimals,
   defineChain,
   defineChainInfo,
   defineChains,
   disconnect,
   executeContract,
+  formatTokenName,
+  getAllBalance,
   getAvailableWallets,
+  getBalance,
   getBalanceStaked,
-  getBalances,
   getCosmostation,
   getKeplr,
   getLeap,
@@ -2998,6 +3351,7 @@ var GrazProvider = ({ children, grazConfig, ...props }) => {
   getWCLeap,
   getWallet,
   getWalletConnect,
+  handleNaN,
   instantiateContract,
   mainnetChains,
   mainnetChainsArray,
@@ -3008,19 +3362,28 @@ var GrazProvider = ({ children, grazConfig, ...props }) => {
   suggestChainAndConnect,
   testnetChains,
   testnetChainsArray,
+  truncate,
   useAccount,
   useActiveChainValidators,
   useActiveWalletType,
+  useAllBalances,
+  useBalance,
   useBalanceStaked,
-  useBalances,
+  useChain,
+  useChainBalances,
   useCheckWallet,
   useConnect,
   useConnectClient,
   useConnectSigningClient,
   useDisconnect,
+  useExecuteContract,
   useGrazEvents,
+  useInstantiateContract,
   useOfflineSigners,
+  useQueryRaw,
+  useQuerySmart,
   useRecentChain,
+  useSendIbcTokens,
   useSendTokens,
   useSuggestChain,
   useSuggestChainAndConnect