graz 0.4.2 → 0.5.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-'use strict';var m=require('fs/promises'),R=require('path'),url=require('url'),cosmos=require('@keplr-wallet/cosmos'),I=require('arg'),cosmosDirectoryClient=require('cosmos-directory-client'),$=require('p-map');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var m__namespace=/*#__PURE__*/_interopNamespace(m);var R__namespace=/*#__PURE__*/_interopNamespace(R);var I__default=/*#__PURE__*/_interopDefault(I);var $__default=/*#__PURE__*/_interopDefault($);var N=()=>typeof document>"u"?new URL(`file:${__filename}`).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href,C=N();var L=R.dirname(url.fileURLToPath(C)),M=n=>/^\d+$/.test(n),_=n=>M(n[0])?`_${n}`:n,b=`Usage: graz [options]
+'use strict';var h=require('fs/promises'),F=require('path'),url=require('url'),cosmos=require('@keplr-wallet/cosmos'),V=require('arg'),cosmosDirectoryClient=require('cosmos-directory-client');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var h__namespace=/*#__PURE__*/_interopNamespace(h);var F__namespace=/*#__PURE__*/_interopNamespace(F);var V__default=/*#__PURE__*/_interopDefault(V);var z=()=>typeof document>"u"?new URL(`file:${__filename}`).href:document.currentScript&&document.currentScript.tagName.toUpperCase()==="SCRIPT"?document.currentScript.src:new URL("main.js",document.baseURI).href,A=z();async function R(t,o,{concurrency:i=Number.POSITIVE_INFINITY,stopOnError:d=true,signal:c}={}){return new Promise((l,e)=>{if(t[Symbol.iterator]===void 0&&t[Symbol.asyncIterator]===void 0)throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof t})`);if(typeof o!="function")throw new TypeError("Mapper function is required");if(!(Number.isSafeInteger(i)&&i>=1||i===Number.POSITIVE_INFINITY))throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${i}\` (${typeof i})`);let r=[],m=[],_=new Map,I=false,n=false,N=false,s=0,P=0,G=t[Symbol.iterator]===void 0?t[Symbol.asyncIterator]():t[Symbol.iterator](),x=()=>{g(c.reason);},$=()=>{c?.removeEventListener("abort",x);},v=f=>{l(f),$();},g=f=>{I=true,n=true,e(f),$();};c&&(c.aborted&&g(c.reason),c.addEventListener("abort",x,{once:true}));let C=async()=>{if(n)return;let f=await G.next(),S=P;if(P++,f.done){if(N=true,s===0&&!n){if(!d&&m.length>0){g(new AggregateError(m));return}if(n=true,_.size===0){v(r);return}let p=[];for(let[u,O]of r.entries())_.get(u)!==j&&p.push(O);v(p);}return}s++,(async()=>{try{let p=await f.value;if(n)return;let u=await o(p,S);u===j&&_.set(S,u),r[S]=u,s--,await C();}catch(p){if(d)g(p);else {m.push(p),s--;try{await C();}catch(u){g(u);}}}})();};(async()=>{for(let f=0;f<i;f++){try{await C();}catch(S){g(S);break}if(N||I)break}})();})}var j=Symbol("skip");var q=F.dirname(url.fileURLToPath(A)),X=t=>/^\d+$/.test(t),w=t=>X(t[0])?`_${t}`:t,D=`Usage: graz [options]
 
 Options:
 
@@ -14,7 +14,7 @@ Generate options:
   --authz               Generate only authz compatible chains
 
 https://github.com/graz-sh/graz
-`,r=I__default.default({"--generate":Boolean,"-g":"--generate","--authz":Boolean,"--best":Boolean,"--mainnet":String,"--testnet":String,"-b":"--best","-M":"--mainnet","-T":"--testnet","--help":Boolean,"-h":"--help","--endpoint":String,"-e":"--endpoint"}),v=async()=>{if(r["--help"]){console.log(b);return}if(r["--generate"]){await x();return}console.log(b);},x=async()=>{console.log("\u23F3	Generating chain list..."),r["--authz"]&&console.log("\u270D\uFE0F	Detected authz flag, generating only compatible chains..."),r["--best"]&&console.log("\u{1F481}\u200D\u2642\uFE0F	Detected best flag, setting REST and RPC endpoints to best latency..."),(r["--mainnet"]||r["--testnet"])&&console.log("\u{1F419}	Detected chain filtering flag, generating only given chain paths...");let n,s;if(r["--endpoint"]){console.log("\u{1F310}	Fetching chain information from specified endpoint");try{let e=await fetch(r["--endpoint"]);if(!e.ok)throw new Error(`HTTP error! status: ${e.status}`);let o=await e.json();n=A(o.mainnet,r["--mainnet"]),s=A(o.testnet,r["--testnet"]);}catch(e){console.error(`\u274C	Failed to fetch chain information: ${e.message}`),process.exit(1);}}else [n,s]=await Promise.all([S(cosmosDirectoryClient.createClient(),{filter:r["--mainnet"]}),S(cosmosDirectoryClient.createTestnetClient(),{filter:r["--testnet"]})]);let[a,d]=await Promise.all([m__namespace.readFile(u("index.js.stub"),{encoding:"utf-8"}),m__namespace.readFile(u("index.mjs.stub"),{encoding:"utf-8"})]),f=a.replace("/* REPLACE_MAINNET_DEFS */",h(n)).replace("/* REPLACE_TESTNET_DEFS */",h(s,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS */",g(n)).replace("/* REPLACE_TESTNET_CHAINS */",g(s,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS_ARRAY */",p(n)).replace("/* REPLACE_TESTNET_CHAINS_ARRAY */",p(s,{testnet:true})).replace("/* REPLACE_MAINNET_EXPORTS */",p(n)).replace("/* REPLACE_TESTNET_EXPORTS */",p(s,{testnet:true})).replace(/"(.+)":/g,"$1:").trim(),c=d.replace("/* REPLACE_MAINNET_DEFS */",h(n,{mjs:true})).replace("/* REPLACE_TESTNET_DEFS */",h(s,{mjs:true,testnet:true})).replace("/* REPLACE_MAINNET_CHAINS */",g(n)).replace("/* REPLACE_TESTNET_CHAINS */",g(s,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS_ARRAY */",p(n)).replace("/* REPLACE_TESTNET_CHAINS_ARRAY */",p(s,{testnet:true})).replace(/"(.+)":/g,"$1:").trim();await Promise.all([m__namespace.writeFile(u("index.js"),f,{encoding:"utf-8"}),m__namespace.writeFile(u("index.mjs"),c.replace('"../dist"','"../dist/index.mjs"'),{encoding:"utf-8"}),m__namespace.writeFile(u("index.ts"),c,{encoding:"utf-8"})]),console.log('\u2728	Generate complete! You can import `mainnetChains` and `testnetChains` from "graz/chains".\n');},A=(n,s)=>{if(!s)return n;let a=new Set(s.split(","));return Object.fromEntries(Object.entries(n).filter(([d])=>a.has(d)))},u=(...n)=>R__namespace.resolve(L,"../chains",...n),g=(n,{testnet:s=false}={})=>Object.keys(n).map(a=>`  ${_(a)}: ${_(a)},`).join(`
-`),h=(n,{mjs:s=false,testnet:a=false}={})=>Object.entries(n).map(([d,f])=>{let c=`${_(d)}`,e=JSON.stringify(f,null,2);return `${s?"export ":""}const ${c} = defineChainInfo(${e});
-`}).join(""),p=(n,{testnet:s=false}={})=>Object.keys(n).map(a=>`  ${_(a)},`).join(`
-`),S=async(n,{filter:s=""}={})=>{let a;if(s)a=s.split(",").map(e=>({path:e}));else try{a=(await n.fetchChains()).chains.map(({path:o})=>({path:o}));}catch(e){return console.error(`\u274C	Failed to fetch chains list: ${e.message}`),{}}let f=(await $__default.default(a,async e=>{try{return (await n.fetchChain(e.path)).chain}catch(o){return console.error(`\u274C	Failed to fetch chain "${e.path}": ${o.message}`),null}},{concurrency:4})).filter(e=>e!==null),c={};return f.forEach(e=>{try{if(r["--authz"]&&!e.params?.authz)return;let o=r["--best"]?e.best_apis:e.apis;if(!o||!o.rest?.[0]||!o.rpc?.[0])throw new Error(`\u26A0\uFE0F	${e.name} has no REST/RPC endpoints, skipping codegen...`);if(!e.assets)throw new Error(`\u26A0\uFE0F	${e.name} has no assets, skipping codegen...`);let l=e.assets[0],T={coinDenom:l.denom_units[l.denom_units.length-1].denom,coinMinimalDenom:l.denom_units[0].denom,coinDecimals:l.denom_units[l.denom_units.length-1].exponent,coinGeckoId:l.coingecko_id},E=e.fees?.fee_tokens.map(t=>t.low_gas_price&&t.average_gas_price&&t.high_gas_price?{coinDenom:e.assets?.find(i=>i.denom===t.denom)?.denom_units.at(-1)?.denom||t.denom,coinMinimalDenom:e.assets?.find(i=>i.denom===t.denom)?.denom_units[0]?.denom||t.denom,coinDecimals:Number(e.assets?.find(i=>i.denom===t.denom)?.decimals),coinGeckoId:e.assets?.find(i=>i.denom===t.denom)?.coingecko_id||void 0,gasPriceStep:{low:Number(t.low_gas_price),average:Number(t.average_gas_price),high:Number(t.high_gas_price)}}:{coinDenom:e.assets?.find(i=>i.denom===t.denom)?.denom_units.at(-1)?.denom||t.denom,coinMinimalDenom:e.assets?.find(i=>i.denom===t.denom)?.denom_units[0]?.denom||t.denom,coinDecimals:Number(e.assets?.find(i=>i.denom===t.denom)?.decimals),coinGeckoId:e.assets?.find(i=>i.denom===t.denom)?.coingecko_id||void 0});if(!E)throw new Error(`\u26A0\uFE0F	${e.name} has no fee currencies, skipping codegen...`);c[e.path]={chainId:e.chain_id,currencies:e.assets.map(t=>({coinDenom:t.denom_units[t.denom_units.length-1].denom,coinMinimalDenom:t.denom_units[0].denom,coinDecimals:t.denom_units[t.denom_units.length-1].exponent,coinGeckoId:t.coingecko_id})),rest:o.rest[0].address||"",rpc:o.rpc[0].address||"",bech32Config:cosmos.Bech32Address.defaultBech32Config(e.bech32_prefix),chainName:e.chain_name,feeCurrencies:E,stakeCurrency:T,bip44:{coinType:e.slip44??0}};}catch(o){console.error(o instanceof Error?o.message:String(o));}}),c};v();
+`,a=V__default.default({"--generate":Boolean,"-g":"--generate","--authz":Boolean,"--best":Boolean,"--mainnet":String,"--testnet":String,"-b":"--best","-M":"--mainnet","-T":"--testnet","--help":Boolean,"-h":"--help","--endpoint":String,"-e":"--endpoint"}),J=async()=>{if(a["--help"]){console.log(D);return}if(a["--generate"]){await K();return}console.log(D);},K=async()=>{console.log("\u23F3	Generating chain list..."),a["--authz"]&&console.log("\u270D\uFE0F	Detected authz flag, generating only compatible chains..."),a["--best"]&&console.log("\u{1F481}\u200D\u2642\uFE0F	Detected best flag, setting REST and RPC endpoints to best latency..."),(a["--mainnet"]||a["--testnet"])&&console.log("\u{1F419}	Detected chain filtering flag, generating only given chain paths...");let t,o;if(a["--endpoint"]){console.log("\u{1F310}	Fetching chain information from specified endpoint");try{let e=await fetch(a["--endpoint"]);if(!e.ok)throw new Error(`HTTP error! status: ${e.status}`);let r=await e.json();t=M(r.mainnet,a["--mainnet"]),o=M(r.testnet,a["--testnet"]);}catch(e){console.error(`\u274C	Failed to fetch chain information: ${e.message}`),process.exit(1);}}else [t,o]=await Promise.all([L(cosmosDirectoryClient.createClient(),{filter:a["--mainnet"]}),L(cosmosDirectoryClient.createTestnetClient(),{filter:a["--testnet"]})]);let[i,d]=await Promise.all([h__namespace.readFile(b("index.js.stub"),{encoding:"utf-8"}),h__namespace.readFile(b("index.mjs.stub"),{encoding:"utf-8"})]),c=i.replace("/* REPLACE_MAINNET_DEFS */",T(t)).replace("/* REPLACE_TESTNET_DEFS */",T(o,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS */",y(t)).replace("/* REPLACE_TESTNET_CHAINS */",y(o,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS_ARRAY */",E(t)).replace("/* REPLACE_TESTNET_CHAINS_ARRAY */",E(o,{testnet:true})).replace("/* REPLACE_MAINNET_EXPORTS */",E(t)).replace("/* REPLACE_TESTNET_EXPORTS */",E(o,{testnet:true})).replace(/"(.+)":/g,"$1:").trim(),l=d.replace("/* REPLACE_MAINNET_DEFS */",T(t,{mjs:true})).replace("/* REPLACE_TESTNET_DEFS */",T(o,{mjs:true,testnet:true})).replace("/* REPLACE_MAINNET_CHAINS */",y(t)).replace("/* REPLACE_TESTNET_CHAINS */",y(o,{testnet:true})).replace("/* REPLACE_MAINNET_CHAINS_ARRAY */",E(t)).replace("/* REPLACE_TESTNET_CHAINS_ARRAY */",E(o,{testnet:true})).replace(/"(.+)":/g,"$1:").trim();await Promise.all([h__namespace.writeFile(b("index.js"),c,{encoding:"utf-8"}),h__namespace.writeFile(b("index.mjs"),l.replace('"../dist"','"../dist/index.mjs"'),{encoding:"utf-8"}),h__namespace.writeFile(b("index.ts"),l,{encoding:"utf-8"})]),console.log('\u2728	Generate complete! You can import `mainnetChains` and `testnetChains` from "graz/chains".\n');},M=(t,o)=>{if(!o)return t;let i=new Set(o.split(","));return Object.fromEntries(Object.entries(t).filter(([d])=>i.has(d)))},b=(...t)=>F__namespace.resolve(q,"../chains",...t),y=(t,{testnet:o=false}={})=>Object.keys(t).map(i=>`  ${w(i)}: ${w(i)},`).join(`
+`),T=(t,{mjs:o=false,testnet:i=false}={})=>Object.entries(t).map(([d,c])=>{let l=`${w(d)}`,e=JSON.stringify(c,null,2);return `${o?"export ":""}const ${l} = defineChainInfo(${e});
+`}).join(""),E=(t,{testnet:o=false}={})=>Object.keys(t).map(i=>`  ${w(i)},`).join(`
+`),L=async(t,{filter:o=""}={})=>{let i;if(o)i=o.split(",").map(e=>({path:e}));else try{i=(await t.fetchChains()).chains.map(({path:r})=>({path:r}));}catch(e){return console.error(`\u274C	Failed to fetch chains list: ${e.message}`),{}}let c=(await R(i,async e=>{try{return (await t.fetchChain(e.path)).chain}catch(r){return console.error(`\u274C	Failed to fetch chain "${e.path}": ${r.message}`),null}},{concurrency:4})).filter(e=>e!==null),l={};return c.forEach(e=>{try{if(a["--authz"]&&!e.params?.authz)return;let r=a["--best"]?e.best_apis:e.apis;if(!r||!r.rest?.[0]||!r.rpc?.[0])throw new Error(`\u26A0\uFE0F	${e.name} has no REST/RPC endpoints, skipping codegen...`);if(!e.assets)throw new Error(`\u26A0\uFE0F	${e.name} has no assets, skipping codegen...`);let m=e.assets[0],_={coinDenom:m.denom_units[m.denom_units.length-1].denom,coinMinimalDenom:m.denom_units[0].denom,coinDecimals:m.denom_units[m.denom_units.length-1].exponent,coinGeckoId:m.coingecko_id},I=e.fees?.fee_tokens.map(n=>n.low_gas_price&&n.average_gas_price&&n.high_gas_price?{coinDenom:e.assets?.find(s=>s.denom===n.denom)?.denom_units.at(-1)?.denom||n.denom,coinMinimalDenom:e.assets?.find(s=>s.denom===n.denom)?.denom_units[0]?.denom||n.denom,coinDecimals:Number(e.assets?.find(s=>s.denom===n.denom)?.decimals),coinGeckoId:e.assets?.find(s=>s.denom===n.denom)?.coingecko_id||void 0,gasPriceStep:{low:Number(n.low_gas_price),average:Number(n.average_gas_price),high:Number(n.high_gas_price)}}:{coinDenom:e.assets?.find(s=>s.denom===n.denom)?.denom_units.at(-1)?.denom||n.denom,coinMinimalDenom:e.assets?.find(s=>s.denom===n.denom)?.denom_units[0]?.denom||n.denom,coinDecimals:Number(e.assets?.find(s=>s.denom===n.denom)?.decimals),coinGeckoId:e.assets?.find(s=>s.denom===n.denom)?.coingecko_id||void 0});if(!I)throw new Error(`\u26A0\uFE0F	${e.name} has no fee currencies, skipping codegen...`);l[e.path]={chainId:e.chain_id,currencies:e.assets.map(n=>({coinDenom:n.denom_units[n.denom_units.length-1].denom,coinMinimalDenom:n.denom_units[0].denom,coinDecimals:n.denom_units[n.denom_units.length-1].exponent,coinGeckoId:n.coingecko_id})),rest:r.rest[0].address||"",rpc:r.rpc[0].address||"",bech32Config:cosmos.Bech32Address.defaultBech32Config(e.bech32_prefix),chainName:e.chain_name,feeCurrencies:I,stakeCurrency:_,bip44:{coinType:e.slip44??0}};}catch(r){console.error(r instanceof Error?r.message:String(r));}}),l};J();

package/dist/index.d.mts

@@ -1,36 +1,30 @@
 /// <reference types="../types/global" />
-import { DirectSignResponse, OfflineDirectSigner, Coin } from '@cosmjs/proto-signing';
-import { Key as Key$1, Keplr, ChainInfo, KeplrSignOptions, KeplrIntereactionOptions, OfflineAminoSigner as OfflineAminoSigner$1, AppCurrency } from '@keplr-wallet/types';
-import { OfflineAminoSigner } from '@cosmjs/amino';
+import { OfflineAminoSigner, StdSignature } from '@cosmjs/amino';
+import { DirectSignResponse, OfflineDirectSigner, Coin, EncodeObject } from '@cosmjs/proto-signing';
+import { Keplr, ChainInfo, KeplrSignOptions, KeplrIntereactionOptions, Key as Key$1, AppCurrency } from '@keplr-wallet/types';
 import { WalletConnectModalConfig } from '@walletconnect/modal';
 import { SignClientTypes } from '@walletconnect/types';
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseQueryResult } from '@tanstack/react-query';
+import { QueryClient, UseQueryResult } from '@tanstack/react-query';
 import { ParaWeb } from '@getpara/web-sdk';
 export { ParaWeb } from '@getpara/web-sdk';
-import { ParaGrazConfig as ParaGrazConfig$1, ParaGrazConnector } from '@getpara/graz-connector';
 import * as _cosmjs_cosmwasm_stargate from '@cosmjs/cosmwasm-stargate';
-import { SigningCosmWasmClient, InstantiateOptions, CosmWasmClient, InstantiateResult, ExecuteResult, SigningCosmWasmClientOptions } from '@cosmjs/cosmwasm-stargate';
-import { SigningStargateClient, StdFee, DeliverTxResponse, QueryClient, StakingExtension, StargateClient, SigningStargateClientOptions } from '@cosmjs/stargate';
-import { Height } from 'cosmjs-types/ibc/core/client/v1/client';
+import { SigningCosmWasmClient, InstantiateOptions, CosmWasmClient, ExecuteResult, InstantiateResult, SigningCosmWasmClientOptions } from '@cosmjs/cosmwasm-stargate';
+import { StdFee, SigningStargateClient, DeliverTxResponse, QueryClient as QueryClient$1, StakingExtension, StargateClient, SigningStargateClientOptions } from '@cosmjs/stargate';
 import { BondStatusString } from '@cosmjs/stargate/build/modules/staking/queries';
-import { QueryValidatorsResponse } from 'cosmjs-types/cosmos/staking/v1beta1/query';
-import { ReactNode, FC } from 'react';
+import { FC, ReactNode } from 'react';
 
 type Dictionary<T = string> = Record<string, T>;
 type Maybe<T> = T | undefined;
 
 declare enum WalletType {
     KEPLR = "keplr",
-    LEAP = "leap",
     VECTIS = "vectis",
     COSMOSTATION = "cosmostation",
     WALLETCONNECT = "walletconnect",
     WC_KEPLR_MOBILE = "wc_keplr_mobile",
-    WC_LEAP_MOBILE = "wc_leap_mobile",
     WC_COSMOSTATION_MOBILE = "wc_cosmostation_mobile",
     WC_CLOT_MOBILE = "wc_clot_mobile",
-    METAMASK_SNAP_LEAP = "metamask_snap_leap",
     METAMASK_SNAP_COSMOS = "metamask_snap_cosmos",
     STATION = "station",
     XDEFI = "xdefi",
@@ -42,11 +36,13 @@ declare enum WalletType {
     CACTUSCOSMOS = "cactuscosmos"
 }
 declare const WALLET_TYPES: WalletType[];
-type Wallet = Pick<Keplr, "enable" | "getOfflineSignerOnlyAmino" | "signAmino"> & {
+type Wallet = Pick<Keplr, "enable" | "signAmino"> & {
     experimentalSuggestChain: (chainInfo: Omit<ChainInfo, "nodeProvider">) => Promise<void>;
     signArbitrary?: Keplr["signArbitrary"];
+    verifyArbitrary?: Keplr["verifyArbitrary"];
     signDirect: (...args: SignDirectParams) => Promise<DirectSignResponse>;
     getOfflineSigner: (chainId: string, signOptions?: KeplrSignOptions) => OfflineAminoSigner & OfflineDirectSigner;
+    getOfflineSignerOnlyAmino: (chainId: string, signOptions?: KeplrSignOptions) => OfflineAminoSigner;
     getOfflineSignerAuto: (chainId: string, signOptions?: KeplrSignOptions) => Promise<OfflineAminoSigner | OfflineDirectSigner>;
     subscription?: (reconnect: () => void) => () => void;
     init?: () => Promise<unknown>;
@@ -93,9 +89,9 @@ type ReconnectArgs = Maybe<{
 }>;
 declare const reconnect: (args?: ReconnectArgs) => Promise<ConnectResult | undefined>;
 interface OfflineSigners {
-    offlineSigner: OfflineAminoSigner$1 & OfflineDirectSigner;
-    offlineSignerAmino: OfflineAminoSigner$1;
-    offlineSignerAuto: OfflineAminoSigner$1 | OfflineDirectSigner;
+    offlineSigner: OfflineAminoSigner & OfflineDirectSigner;
+    offlineSignerAmino: OfflineAminoSigner;
+    offlineSignerAuto: OfflineAminoSigner | OfflineDirectSigner;
 }
 declare const getOfflineSigners: (args?: {
     walletType?: WalletType;
@@ -243,9 +239,10 @@ interface ParaWallet {
 }
 /**
  * Event callbacks for Para wallet connector lifecycle events
- * Extracted from @getpara/graz-connector ParaGrazConfig
  */
-type ParaGrazConnectorEvents = NonNullable<ParaGrazConfig$1["events"]>;
+interface ParaGrazConnectorEvents {
+    onEnabled?: (chainIds: string[], connector: ParaGrazConnector) => void;
+}
 /**
  * Modal props for Para wallet UI
  * Compatible with ParaModalProps from @getpara/react-sdk-lite
@@ -296,7 +293,19 @@ interface ParaGrazConfig {
      * Should match the client used in your app's QueryClientProvider
      * Only needed when using @getpara/graz-integration with modal support
      */
-    queryClient?: _tanstack_react_query.QueryClient;
+    queryClient?: QueryClient;
+}
+/**
+ * Para wallet connector interface
+ *
+ * Structural contract for the connector instance provided by
+ * @getpara/graz-integration. Defined here so graz's published types stay
+ * self-contained and do not pin a specific @getpara/graz-connector install.
+ */
+interface ParaGrazConnector extends Pick<Wallet, "enable" | "getKey" | "getOfflineSigner" | "getOfflineSignerOnlyAmino" | "getOfflineSignerAuto" | "signAmino" | "signDirect"> {
+    disconnect: () => Promise<void>;
+    getParaWebClient: () => ParaWeb;
+    signArbitrary: (chainId: string, signer: string, data: string | Uint8Array) => Promise<StdSignature>;
 }
 
 interface ChainConfig {
@@ -309,7 +318,7 @@ interface ChainConfig {
 }
 interface WalletConnectStore {
     options: SignClientTypes.Options | null;
-    walletConnectModal?: Pick<WalletConnectModalConfig, "themeVariables" | "themeMode" | "privacyPolicyUrl" | "termsOfServiceUrl"> | null;
+    walletConnectModal?: Pick<WalletConnectModalConfig, "themeVariables" | "themeMode" | "privacyPolicyUrl" | "termsOfServiceUrl" | "mobileWallets" | "desktopWallets"> | null;
 }
 interface IframeOptions {
     /**
@@ -381,6 +390,10 @@ interface ConfigureGrazArgs {
      * Options to enable iframe wallet connection.
      */
     iframeOptions?: IframeOptions;
+    /**
+     * Prefix persisted Graz storage keys, useful when multiple Graz apps share one origin.
+     */
+    prefixStorageKey?: string;
     pingInteval?: number;
     /**
      * Logger configuration
@@ -393,6 +406,36 @@ interface ConfigureGrazArgs {
 }
 declare const configureGraz: (args: ConfigureGrazArgs) => ConfigureGrazArgs;
 
+interface Height {
+    revisionNumber: bigint;
+    revisionHeight: bigint;
+}
+interface SignArbitraryArgs {
+    walletType?: WalletType;
+    chainId: string;
+    signerAddress: string;
+    data: string | Uint8Array;
+}
+interface VerifyArbitraryArgs extends SignArbitraryArgs {
+    signature: StdSignature;
+}
+/**
+ * Sign arbitrary data using the active wallet's ADR-36-compatible signing API.
+ */
+declare const signArbitrary: ({ walletType, chainId, signerAddress, data, }: SignArbitraryArgs) => Promise<StdSignature>;
+/**
+ * Verify arbitrary data using the active wallet's ADR-36-compatible verification API.
+ */
+declare const verifyArbitrary: ({ walletType, chainId, signerAddress, data, signature, }: VerifyArbitraryArgs) => Promise<boolean>;
+interface SignAndBroadcastArgs {
+    signingClient?: SigningStargateClient;
+    senderAddress?: string;
+    messages: readonly EncodeObject[];
+    fee: number | StdFee | "auto";
+    memo?: string;
+    timeoutHeight?: bigint;
+}
+declare const signAndBroadcast: ({ signingClient, senderAddress, messages, fee, memo, timeoutHeight, }: SignAndBroadcastArgs) => Promise<DeliverTxResponse>;
 interface SendTokensArgs {
     signingClient?: SigningStargateClient | SigningCosmWasmClient;
     senderAddress?: string;
@@ -471,8 +514,6 @@ declare const clearSession: () => void;
  */
 declare const getWallet: (type?: WalletType) => Wallet;
 declare const getAvailableWallets: () => Record<WalletType, boolean>;
-declare const isLeapSnaps: (type: WalletType) => boolean;
-declare const isLeapDappBrowser: () => boolean;
 declare const isWalletConnect: (type: WalletType) => boolean;
 declare const isPara: (type: WalletType) => type is WalletType.PARA;
 
@@ -593,38 +634,6 @@ declare const getCosmostation: () => Wallet;
  */
 declare const getKeplr: () => Wallet;
 
-/**
- * Function to return Leap object (which is {@link Wallet}) and throws and error if it does not exist on `window`.
- *
- * @example
- * ```ts
- * try {
- *   const leap = getLeap();
- * } catch (error: Error) {
- *   console.error(error.message);
- * }
- * ```
- *
- * @see https://docs.leapwallet.io/cosmos/for-dapps-connect-to-leap/add-leap-to-existing-keplr-integration
- */
-declare const getLeap: () => Wallet;
-
-/**
- * Function to return {@link Wallet} object and throws and error if it does not exist on `window`.
- *
- * @example
- * ```ts
- * try {
- *   const leapMetamaskSnap = getMetamaskSnapLeap();
- * } catch (error: Error) {
- *   console.error(error.message);
- * }
- * ```
- *
- *
- */
-declare const getMetamaskSnapLeap: () => Wallet;
-
 /**
  * Function to return okxwallet object (which is {@link Wallet}) and throws and error if it does not exist on `window`.
  *
@@ -661,7 +670,7 @@ declare const getVectis: () => Wallet;
 
 interface GetWalletConnectParams {
     encoding: BufferEncoding;
-    walletType: WalletType.WC_KEPLR_MOBILE | WalletType.WC_LEAP_MOBILE | WalletType.WC_COSMOSTATION_MOBILE | WalletType.WC_CLOT_MOBILE;
+    walletType: WalletType.WC_KEPLR_MOBILE | WalletType.WC_COSMOSTATION_MOBILE | WalletType.WC_CLOT_MOBILE;
     appUrl: {
         mobile: {
             ios: string;
@@ -677,8 +686,6 @@ declare const getWCCosmostation: () => Wallet;
 
 declare const getWCKeplr: () => Wallet;
 
-declare const getWCLeap: () => Wallet;
-
 /**
  * Helper function to define chain information records (key values).
  *
@@ -790,6 +797,13 @@ interface UseAccountResult<TChainIds extends readonly string[] | undefined> {
     status: string;
     walletType?: WalletType;
 }
+type UseBalancesArgs = {
+    bech32Address: string | undefined;
+    chainId: string | undefined;
+} & QueryConfig;
+type UseBalanceArgs = UseBalancesArgs & {
+    denom: string | undefined;
+};
 /**
  * graz query hook to retrieve account data with optional arguments to invoke
  * given function on connect/disconnect.
@@ -847,10 +861,7 @@ declare function useAccount(args?: UseAccountArgs): UseAccountResult<undefined>;
  * // Type: { data?: Coin[] }
  * ```
  */
-declare const useBalances: (args: {
-    bech32Address: string;
-    chainId: string;
-} & QueryConfig) => UseQueryResult<Coin[], unknown>;
+declare const useBalances: (args: UseBalancesArgs) => UseQueryResult<Coin[], unknown>;
 /**
  * graz query hook to retrieve specific asset balance for a specific chain and address.
  *
@@ -870,11 +881,7 @@ declare const useBalances: (args: {
  * // Type: { data?: Coin | undefined }
  * ```
  */
-declare const useBalance: (args: {
-    bech32Address: string;
-    chainId: string;
-    denom: string;
-} & QueryConfig) => UseQueryResult<Coin | undefined, unknown>;
+declare const useBalance: (args: UseBalanceArgs) => UseQueryResult<Coin | undefined, unknown>;
 type UseConnectChainArgs = MutationEventArgs<ConnectArgs, ConnectResult>;
 /**
  * graz mutation hook to execute wallet connection with optional arguments to
@@ -1007,11 +1014,9 @@ declare function useOfflineSigners(args?: Record<string, never>): UseMultiChainQ
  * // Type: { data?: Coin }
  * ```
  */
-declare const useBalanceStaked: (args: {
-    bech32Address: string;
-    chainId: string;
-} & QueryConfig) => UseQueryResult<Coin, unknown>;
+declare const useBalanceStaked: (args: UseBalancesArgs) => UseQueryResult<Coin | null, unknown>;
 
+type QueryValidatorsResponse = Awaited<ReturnType<StakingExtension["staking"]["validators"]>>;
 /**
  * graz hook to retrieve connected account's active chainIds
  *
@@ -1077,8 +1082,8 @@ declare const useChainInfos: ({ chainId }?: {
  * const { data: currency, ... } = useActiveChainCurrency({denom: "juno"});
  * ```
  */
-declare const useActiveChainCurrency: ({ denom }: {
-    denom: string;
+declare const useActiveChainCurrency: ({ denom, }: {
+    denom: string | undefined;
 }) => UseQueryResult<AppCurrency | undefined>;
 /**
  * graz hook to retrieve active chain validators with given query client and optional bond status
@@ -1095,7 +1100,7 @@ declare const useActiveChainCurrency: ({ denom }: {
  * const { data: response, ... } = useActiveChainValidators(queryClient);
  * ```
  */
-declare const useQueryClientValidators: <T extends QueryClient & StakingExtension>(args: {
+declare const useQueryClientValidators: <T extends QueryClient$1 & StakingExtension>(args: {
     queryClient: T | undefined;
     status?: BondStatusString;
 }) => UseQueryResult<QueryValidatorsResponse>;
@@ -1323,6 +1328,228 @@ declare function useCosmWasmClient<const TChainIds extends readonly string[]>(ar
 } & QueryConfig): UseMultiChainQueryResult<TChainIds, CosmWasmClient>;
 declare function useCosmWasmClient(args?: QueryConfig): UseMultiChainQueryResult<undefined, CosmWasmClient>;
 
+/**
+ * graz mutation hook to sign arbitrary data using the active wallet.
+ *
+ * @see {@link signArbitrary}
+ */
+declare const useSignArbitrary: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SignArbitraryArgs, StdSignature>) => {
+    signArbitrary: _tanstack_react_query.UseMutateFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    signArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signArbitrary: _tanstack_react_query.UseMutateFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    signArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    data: undefined;
+    variables: SignArbitraryArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signArbitrary: _tanstack_react_query.UseMutateFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    signArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: SignArbitraryArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signArbitrary: _tanstack_react_query.UseMutateFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    signArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<StdSignature, Error, SignArbitraryArgs, unknown>;
+    data: StdSignature;
+    error: null;
+    variables: SignArbitraryArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * graz mutation hook to verify arbitrary data using the active wallet.
+ *
+ * @see {@link verifyArbitrary}
+ */
+declare const useVerifyArbitrary: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<VerifyArbitraryArgs, boolean>) => {
+    verifyArbitrary: _tanstack_react_query.UseMutateFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    verifyArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    verifyArbitrary: _tanstack_react_query.UseMutateFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    verifyArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    data: undefined;
+    variables: VerifyArbitraryArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    verifyArbitrary: _tanstack_react_query.UseMutateFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    verifyArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: VerifyArbitraryArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    verifyArbitrary: _tanstack_react_query.UseMutateFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    verifyArbitraryAsync: _tanstack_react_query.UseMutateAsyncFunction<boolean, Error, VerifyArbitraryArgs, unknown>;
+    data: boolean;
+    error: null;
+    variables: VerifyArbitraryArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * graz mutation hook to sign and broadcast arbitrary encoded messages.
+ *
+ * @see {@link signAndBroadcast}
+ */
+declare const useSignAndBroadcast: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SignAndBroadcastArgs, DeliverTxResponse>) => {
+    signAndBroadcast: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    signAndBroadcastAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signAndBroadcast: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    signAndBroadcastAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    data: undefined;
+    variables: SignAndBroadcastArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signAndBroadcast: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    signAndBroadcastAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: SignAndBroadcastArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    signAndBroadcast: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    signAndBroadcastAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SignAndBroadcastArgs, unknown>;
+    data: DeliverTxResponse;
+    error: null;
+    variables: SignAndBroadcastArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
 /**
  * graz mutation hook to send tokens.
  *
@@ -1840,11 +2067,8 @@ declare const useActiveWalletType: () => {
     isCosmostationMobile: boolean;
     isKeplr: boolean;
     isKeplrMobile: boolean;
-    isLeap: boolean;
-    isLeapMobile: boolean;
     isVectis: boolean;
     isWalletConnect: boolean;
-    isMetamaskSnapLeap: boolean;
     isStation: boolean;
     isCosmiframe: boolean;
 };
@@ -1875,7 +2099,7 @@ interface GrazProviderProps {
  * // example next.js application in _app.tsx
  * export default function CustomApp({ Component, pageProps }: AppProps) {
  *   return (
- *     <QueryClientProvider queryClient={queryClient}>
+ *     <QueryClientProvider client={queryClient}>
  *       <GrazProvider grazOptions={{
  *         chains: [cosmoshubChainInfo, osmosisChainInfo],
  *         logger: {
@@ -1896,7 +2120,7 @@ interface GrazProviderProps {
 declare const GrazProvider: FC<GrazProviderProps>;
 
 /**
- * Graz custom hook to track `keplr_keystorechange`, `leap_keystorechange`, `accountChanged` event and reconnect state
+ * Graz custom hook to track `keplr_keystorechange`, `accountChanged` event and reconnect state
  *
  * **Note: only use this hook if not using graz's provider component.**
  */
@@ -1908,4 +2132,4 @@ declare const useGrazEvents: () => null;
  */
 declare const GrazEvents: FC;
 
-export { type ActionChainId, type AddChainArgs, type CactusCosmosWallet, type ConfigureGrazArgs, type ConnectArgs, type ConnectResult, type Dictionary, type ErrorReporter, type ExecuteContractArgs, type ExecuteContractMutationArgs, GrazEvents, GrazProvider, type GrazProviderProps, type InstantiateContractArgs, type InstantiateContractMutationArgs, type Key, type KnownKeys, LOG_CATEGORIES, LOG_FUNCTIONS, LOG_HOOKS, LogCategory, LogLevel, type Logger, type LoggerOptions, type Maybe, type OfflineSigners, type ParaGrazConfig, type ParaGrazConnectorEvents, type ParaModalProps, type ParaWallet, type ReconnectArgs, type SendIbcTokensArgs, type SendTokensArgs, type SignAminoParams, type SignDirectParams, type SignDoc, type SuggestChainAndConnectArgs, type SuggestChainArgs, type UseAccountArgs, type UseAccountResult, type UseAddChainArgs, type UseConnectChainArgs, type UseExecuteContractArgs, type UseInstantiateContractArgs, type UseSuggestChainAndConnectArgs, type UseSuggestChainArgs, WALLET_TYPES, type Wallet, WalletType, addChain, checkWallet, clearRecentChain, clearSession, configureGraz, configureLogger, connect, defineChainInfo, defineChains, disconnect, executeContract, getAvailableWallets, getCactusCosmos, getChainInfo, getChainInfos, getCosmostation, getKeplr, getLeap, getLogger, getMetamaskSnapLeap, getOfflineSigners, getOkx, getPara, getQueryRaw, getQuerySmart, getRecentChainIds, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, instantiateContract, isLeapDappBrowser, isLeapSnaps, isPara, isWalletConnect, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, useAccount, useActiveChainCurrency, useActiveChainIds, useActiveChains, useActiveWalletType, useAddChain, useBalance, useBalanceStaked, useBalances, useChainInfo, useChainInfos, useCheckWallet, useConnect, useCosmWasmClient, useCosmWasmSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryClientValidators, useQueryRaw, useQuerySmart, useRecentChainIds, useRecentChains, useSendIbcTokens, useSendTokens, useStargateClient, useStargateSigningClient, useSuggestChain, useSuggestChainAndConnect };
+export { type ActionChainId, type AddChainArgs, type CactusCosmosWallet, type ConfigureGrazArgs, type ConnectArgs, type ConnectResult, type Dictionary, type ErrorReporter, type ExecuteContractArgs, type ExecuteContractMutationArgs, GrazEvents, GrazProvider, type GrazProviderProps, type Height, type InstantiateContractArgs, type InstantiateContractMutationArgs, type Key, type KnownKeys, LOG_CATEGORIES, LOG_FUNCTIONS, LOG_HOOKS, LogCategory, LogLevel, type Logger, type LoggerOptions, type Maybe, type OfflineSigners, type ParaGrazConfig, type ParaGrazConnector, type ParaGrazConnectorEvents, type ParaModalProps, type ParaWallet, type ReconnectArgs, type SendIbcTokensArgs, type SendTokensArgs, type SignAminoParams, type SignAndBroadcastArgs, type SignArbitraryArgs, type SignDirectParams, type SignDoc, type SuggestChainAndConnectArgs, type SuggestChainArgs, type UseAccountArgs, type UseAccountResult, type UseAddChainArgs, type UseConnectChainArgs, type UseExecuteContractArgs, type UseInstantiateContractArgs, type UseSuggestChainAndConnectArgs, type UseSuggestChainArgs, type VerifyArbitraryArgs, WALLET_TYPES, type Wallet, WalletType, addChain, checkWallet, clearRecentChain, clearSession, configureGraz, configureLogger, connect, defineChainInfo, defineChains, disconnect, executeContract, getAvailableWallets, getCactusCosmos, getChainInfo, getChainInfos, getCosmostation, getKeplr, getLogger, getOfflineSigners, getOkx, getPara, getQueryRaw, getQuerySmart, getRecentChainIds, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWallet, getWalletConnect, instantiateContract, isPara, isWalletConnect, reconnect, sendIbcTokens, sendTokens, signAndBroadcast, signArbitrary, suggestChain, suggestChainAndConnect, useAccount, useActiveChainCurrency, useActiveChainIds, useActiveChains, useActiveWalletType, useAddChain, useBalance, useBalanceStaked, useBalances, useChainInfo, useChainInfos, useCheckWallet, useConnect, useCosmWasmClient, useCosmWasmSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryClientValidators, useQueryRaw, useQuerySmart, useRecentChainIds, useRecentChains, useSendIbcTokens, useSendTokens, useSignAndBroadcast, useSignArbitrary, useStargateClient, useStargateSigningClient, useSuggestChain, useSuggestChainAndConnect, useVerifyArbitrary, verifyArbitrary };