@vechain/vechain-kit 2.0.0-rc.3 → 2.0.0-rc.4

package/dist/index.js

@@ -1,5 +1,5 @@
-import { SubdomainClaimer__factory, IReverseRegistrar__factory, SimpleAccountFactory__factory, SimpleAccount__factory, NodeManagement__factory, VeBetterPassport__factory, XAllocationVoting__factory, X2EarnApps__factory, XAllocationVotingGovernor__factory, ERC20__factory, B3TR__factory, IERC20__factory, IVechainEnergyOracleV1__factory, VOT3__factory, VoterRewards__factory, XAllocationPool__factory, GalaxyMember__factory, MockENS__factory, IB3TR__factory, IVOT3__factory } from './chunk-FOSPSOWT.js';
-import { VECHAIN_KIT_MIXPANEL_PROJECT_TOKEN, ENV, TIME, humanAddress, TOKEN_LOGO_COMPONENTS, TOKEN_LOGOS, DEFAULT_PRIVY_ECOSYSTEM_APPS, executeCallClause, getConfig, convertUriToUrl, ENS_TEXT_RECORDS, getPicassoImage, VECHAIN_PRIVY_APP_ID, compareAddresses, resolveMediaTypeFromMimeType, humanDomain, isRejectionError, isValidAddress, humanNumber, VECHAIN_KIT_COOKIES_CONFIG, VECHAIN_KIT_STORAGE_KEYS, CURRENCY_SYMBOLS, uploadBlobToIPFS, randomTransactionUser, executeMultipleClausesCall, VECHAIN_KIT_TERMS_CONFIG, isValidUrl, notFoundImage } from './chunk-SNDIAFF7.js';
+import { SubdomainClaimer__factory, IReverseRegistrar__factory, XAllocationVoting__factory, VeBetterPassport__factory, XAllocationPool__factory, X2EarnApps__factory, SimpleAccountFactory__factory, SimpleAccount__factory, ERC20__factory, IVechainEnergyOracleV1__factory, B3TR__factory, IERC20__factory, IVOT3__factory, MockENS__factory } from './chunk-FOSPSOWT.js';
+import { VECHAIN_KIT_MIXPANEL_PROJECT_TOKEN, ENV, TIME, humanAddress, TOKEN_LOGO_COMPONENTS, TOKEN_LOGOS, DEFAULT_PRIVY_ECOSYSTEM_APPS, executeCallClause, getConfig, convertUriToUrl, ENS_TEXT_RECORDS, getPicassoImage, humanNumber, executeMultipleClausesCall, VECHAIN_PRIVY_APP_ID, compareAddresses, resolveMediaTypeFromMimeType, humanDomain, isRejectionError, isValidAddress, VECHAIN_KIT_COOKIES_CONFIG, VECHAIN_KIT_STORAGE_KEYS, CURRENCY_SYMBOLS, uploadBlobToIPFS, randomTransactionUser, VECHAIN_KIT_TERMS_CONFIG, isValidUrl, notFoundImage } from './chunk-SNDIAFF7.js';
 export { CURRENCY_SYMBOLS, ENS_TEXT_RECORDS, LegalDocumentSource, LegalDocumentType, NFTMediaType, VePassportUserStatus, buildCallClauses, executeCallClause, executeMultipleClausesCall, getConfig } from './chunk-SNDIAFF7.js';
 import { VechainLogo, VechainLogoLight, VechainLogoDark, VeWorldLogoLight, VeWorldLogoDark, VechainEnergy, SimpleAccountFactoryABI, SimpleAccountABI, PrivyLogo } from './chunk-Z4FE6MMP.js';
 import './chunk-PZ5AY32C.js';
@@ -11,7 +11,7 @@ import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
 import { useThor, useWallet as useWallet$1, useWalletModal, DAppKitProvider } from '@vechain/dapp-kit-react';
 export { WalletButton as DAppKitWalletButton, useWallet as useDAppKitWallet, useWalletModal as useDAppKitWalletModal, useThor } from '@vechain/dapp-kit-react';
 import React10, { createContext, useEffect, useState, useRef, useCallback, useMemo, useContext, Fragment as Fragment$1 } from 'react';
-import { useQuery, useQueryClient, useQueries, useInfiniteQuery, QueryClient, QueryClientContext, QueryClientProvider } from '@tanstack/react-query';
+import { useQuery, useQueryClient, useQueries, QueryClientContext, QueryClientProvider, QueryClient } from '@tanstack/react-query';
 import { hashFn } from 'wagmi/query';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { motion } from 'framer-motion';
@@ -20,14 +20,15 @@ import { IoChevronBack, IoCheckmarkOutline, IoCopyOutline, IoWalletOutline, IoCl
 import { FaRegAddressCard, FaExternalLinkAlt, FaGlobe, FaEnvelope, FaArrowRight, FaTelegramPlane, FaChevronDown, FaEdit, FaGoogle, FaTwitter, FaPhone, FaSpotify, FaApple, FaInstagram, FaTiktok, FaGithub, FaLinkedin, FaTelegram, FaDiscord as FaDiscord$1, FaWallet, FaPlus } from 'react-icons/fa';
 import { HiOutlineWallet, HiOutlineShieldCheck } from 'react-icons/hi2';
 import VeChainKitMixpanel from 'mixpanel-browser';
-import { Interface, isAddress, ethers, namehash, toUtf8String, zeroPadValue, toBeHex, formatEther as formatEther$1, parseEther as parseEther$1 } from 'ethers';
+import { Interface, isAddress, ethers, namehash, toUtf8String, zeroPadValue, toBeHex, formatEther, parseEther as parseEther$1 } from 'ethers';
 import { ZERO_ADDRESS, Address, Clause, ABIContract } from '@vechain/sdk-core';
-import { defineChain, namehash as namehash$1, formatEther, parseEther, keccak256, toBytes, concat, encodeFunctionData } from 'viem';
+import { defineChain, namehash as namehash$1, formatEther as formatEther$1, parseEther, keccak256, toBytes, concat, encodeFunctionData } from 'viem';
 import { z } from 'zod';
+import { BigNumber } from 'bignumber.js';
 import { useAccount, useConnect, useSignTypedData, useSignMessage, useDisconnect, createConfig, http, WagmiProvider } from 'wagmi';
 import { toPrivyWalletConnector } from '@privy-io/cross-app-connect/rainbow-kit';
 import { isMobile } from 'react-device-detect';
-import BigNumber$1, { BigNumber } from 'bignumber.js';
+import axios from 'axios';
 import imageCompression from 'browser-image-compression';
 import { LuMail, LuArrowDownToLine } from 'react-icons/lu';
 import { MdOutlineNavigateNext, MdSwapHoriz, MdOutlineSettingsBackupRestore, MdPhotoCamera, MdCurrencyExchange, MdPrivacyTip, MdOutlineRefresh, MdOutlineErrorOutline, MdEmail, MdGavel, MdCheck } from 'react-icons/md';
@@ -4354,15 +4355,15 @@ var Analytics = {
         loginMethod
       });
     },
-    tryAgain: (method13, platform) => {
+    tryAgain: (method7, platform) => {
       Analytics.auth.trackAuth("try_again", {
-        loginMethod: method13,
+        loginMethod: method7,
         platform
       });
     },
-    methodSelected: (method13) => {
+    methodSelected: (method7) => {
       Analytics.auth.trackAuth("method_selected", {
-        loginMethod: method13
+        loginMethod: method7
       });
     },
     completed: ({
@@ -4817,7 +4818,7 @@ var AddressDisplay = ({
 
 // package.json
 var package_default = {
-  version: "2.0.0-rc.3"};
+  version: "2.0.0-rc.4"};
 var VersionFooter = ({ ...props }) => {
   const { darkMode: isDark } = useVeChainKitConfig();
   return /* @__PURE__ */ jsxs(
@@ -6120,13 +6121,13 @@ var useUnsetDomain = ({
     }
   };
 };
-var useTokenBalances = ({ address = "" }) => {
+var useTokenBalances = (address) => {
   const { network } = useVeChainKitConfig();
   const config = getConfig(network.type);
   const { data: vetData, isLoading: vetLoading } = useAccountBalance(address);
   const { data: b3trBalance, isLoading: b3trLoading } = useGetB3trBalance(address);
   const { data: vot3Balance, isLoading: vot3Loading } = useGetVot3Balance(address);
-  const { data: veDelegateBalance, isLoading: veDelegateLoading } = useGetVeDelegateBalance(address);
+  const { data: veDelegateBalance, isLoading: veDelegateLoading } = useGetErc20Balance(config.veDelegateTokenContractAddress, address);
   const { data: gloDollarBalance, isLoading: gloDollarLoading } = useGetErc20Balance(config.gloDollarContractAddress, address);
   const customTokenBalancesQueries = useGetCustomTokenBalances(address);
   const customTokenBalances = customTokenBalancesQueries.map((query) => query.data).filter(Boolean);
@@ -6199,6 +6200,36 @@ var useTokenBalances = ({ address = "" }) => {
     isLoading
   };
 };
+var PRICE_FEED_IDS = {
+  B3TR: "0x623374722d757364000000000000000000000000000000000000000000000000",
+  VET: "0x7665742d75736400000000000000000000000000000000000000000000000000",
+  VTHO: "0x7674686f2d757364000000000000000000000000000000000000000000000000",
+  GBP: "0x6762702d75736400000000000000000000000000000000000000000000000000",
+  EUR: "0x657572742d757364000000000000000000000000000000000000000000000000"
+};
+var getTokenUsdPrice = async (thor, token, network) => {
+  const res = await thor.contracts.load(
+    getConfig(network).oracleContractAddress,
+    IVechainEnergyOracleV1__factory.abi
+  ).read.getLatestValue(PRICE_FEED_IDS[token]);
+  if (!res) throw new Error(`Failed to get price of ${token}`);
+  return new BigNumber(res[0].toString()).div(1e12).toNumber();
+};
+var getTokenUsdPriceQueryKey = (token) => [
+  "VECHAIN_KIT_PRICE",
+  token
+];
+var useGetTokenUsdPrice = (token) => {
+  const thor = useThor();
+  const { network } = useVeChainKitConfig();
+  return useQuery({
+    queryKey: getTokenUsdPriceQueryKey(token),
+    queryFn: async () => getTokenUsdPrice(thor, token, network.type),
+    enabled: !!thor && !!network.type
+  });
+};
+
+// src/hooks/api/wallet/useTokenPrices.ts
 var useTokenPrices = () => {
   const { network } = useVeChainKitConfig();
   const config = getConfig(network.type);
@@ -6288,9 +6319,7 @@ var useCurrency = () => {
 var useTokensWithValues = ({
   address = ""
 }) => {
-  const { balances, isLoading: balancesLoading } = useTokenBalances({
-    address
-  });
+  const { balances, isLoading: balancesLoading } = useTokenBalances(address);
   const {
     prices,
     exchangeRates,
@@ -6359,6 +6388,60 @@ var useTotalBalance = ({ address = "" }) => {
     hasAnyBalance: tokensWithBalance.length > 0
   };
 };
+
+// src/hooks/api/wallet/useCurrentAllocationsRoundId.ts
+var abi = XAllocationVoting__factory.abi;
+var method = "currentRoundId";
+var getCurrentAllocationsRoundIdQueryKey = (address) => getCallClauseQueryKey({ abi, address, method });
+var useCurrentAllocationsRoundId = () => {
+  const { network } = useVeChainKitConfig();
+  const address = getConfig(network.type).xAllocationVotingContractAddress;
+  return useCallClause({
+    abi,
+    address,
+    method,
+    args: [],
+    queryOptions: {
+      select: (data) => data[0].toString()
+    }
+  });
+};
+var getTokenInfo = async (thor, tokenAddress) => {
+  if (!tokenAddress) throw new Error("Token address is required");
+  const contract = thor.contracts.load(tokenAddress, ERC20__factory.abi);
+  const response = await thor.contracts.executeMultipleClausesCall([
+    contract.clause.name(),
+    contract.clause.symbol(),
+    contract.clause.decimals()
+  ]);
+  if (response.every((r) => r.success) === false) {
+    throw new Error(`Failed to get token info of ${tokenAddress}`);
+  }
+  const [name, symbol, decimals] = response.map((res) => {
+    return res.result.array?.[0];
+  });
+  return {
+    name,
+    address: tokenAddress,
+    decimals,
+    symbol
+  };
+};
+var getCustomTokenInfo = (tokenAddress) => [
+  "VECHAIN_KIT_CUSTOM_TOKEN_BALANCE",
+  tokenAddress
+];
+var useGetCustomTokenInfo = (tokenAddress) => {
+  const thor = useThor();
+  const { network } = useVeChainKitConfig();
+  return useQuery({
+    queryKey: getCustomTokenInfo(tokenAddress),
+    queryFn: async () => getTokenInfo(thor, tokenAddress),
+    enabled: !!thor && !!network.type && !!tokenAddress
+  });
+};
+
+// src/hooks/api/wallet/useCustomTokens.ts
 var useCustomTokens = () => {
   const [customTokens, setCustomTokens] = useLocalStorage(
     "vechain_kit_custom_tokens" /* CUSTOM_TOKENS */,
@@ -6405,6 +6488,223 @@ var useCustomTokens = () => {
     isDefaultToken
   };
 };
+var getB3trBalance = async (thor, network, address) => {
+  const res = await thor.contracts.load(getConfig(network).b3trContractAddress, B3TR__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error("Failed to get b3tr balance");
+  const original = res[0].toString();
+  const scaled = formatEther(original);
+  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getB3trBalanceQueryKey = (address) => [
+  "VEBETTERDAO_BALANCE",
+  address,
+  "B3TR"
+];
+var useGetB3trBalance = (address) => {
+  const thor = useThor();
+  const { network } = useVeChainKitConfig();
+  return useQuery({
+    queryKey: getB3trBalanceQueryKey(address),
+    queryFn: async () => getB3trBalance(thor, network.type, address),
+    enabled: !!thor && !!address && !!network.type
+  });
+};
+var getCustomTokenBalance = async (thor, token, address) => {
+  const res = await thor.contracts.load(token.address, ERC20__factory.abi).read.balanceOf([address]);
+  if (!res) throw new Error(`Failed to get balance of ${token.address}`);
+  const original = res[0];
+  const scaled = formatEther$1(BigInt(original));
+  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
+  return {
+    ...token,
+    original: original.toString(),
+    scaled,
+    formatted
+  };
+};
+var getCustomTokenBalanceQueryKey = (tokenAddress, address) => ["VECHAIN_KIT_BALANCE", address, "CUSTOM_TOKEN", tokenAddress];
+var useGetCustomTokenBalances = (address) => {
+  const thor = useThor();
+  const { customTokens } = useCustomTokens();
+  return useQueries({
+    queries: customTokens.map((token) => ({
+      queryKey: getCustomTokenBalanceQueryKey(token.address, address),
+      queryFn: async () => {
+        return await getCustomTokenBalance(thor, token, address);
+      }
+    }))
+  });
+};
+var getErc20Balance = async (thor, tokenAddress, address) => {
+  if (!tokenAddress || !address) {
+    throw new Error("Token address and user address are required");
+  }
+  const res = await thor.contracts.load(tokenAddress, IERC20__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error(`Failed to get balance of ${tokenAddress}`);
+  const original = res[0].toString();
+  const scaled = formatEther(original);
+  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getErc20BalanceQueryKey = (tokenAddress, address) => ["VECHAIN_KIT", "BALANCE", "ERC20", tokenAddress, address];
+var useGetErc20Balance = (tokenAddress, address) => {
+  const thor = useThor();
+  return useQuery({
+    queryKey: getErc20BalanceQueryKey(tokenAddress, address),
+    queryFn: async () => getErc20Balance(thor, tokenAddress, address),
+    enabled: !!thor && !!address && !!tokenAddress
+  });
+};
+var getVot3Balance = async (thor, network, address) => {
+  const res = await thor.contracts.load(getConfig(network).vot3ContractAddress, IVOT3__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error("Reverted");
+  const original = res[0].toString();
+  const scaled = formatEther(original);
+  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getVot3BalanceQueryKey = (address) => [
+  "VEBETTERDAO_BALANCE",
+  address,
+  "VOT3"
+];
+var useGetVot3Balance = (address) => {
+  const thor = useThor();
+  const { network } = useVeChainKitConfig();
+  return useQuery({
+    queryKey: getVot3BalanceQueryKey(address),
+    queryFn: async () => getVot3Balance(thor, network.type, address),
+    enabled: !!thor && !!address && !!network.type
+  });
+};
+
+// src/hooks/api/wallet/useIsPerson.ts
+var abi2 = VeBetterPassport__factory.abi;
+var method2 = "isPerson";
+var getIsPersonQueryKey = (user, network) => {
+  const address = getConfig(network).veBetterPassportContractAddress;
+  return getCallClauseQueryKeyWithArgs({
+    abi: abi2,
+    address,
+    method: method2,
+    args: [user]
+  });
+};
+var useIsPerson = (user) => {
+  const { network } = useVeChainKitConfig();
+  const address = getConfig(network.type).veBetterPassportContractAddress;
+  return useCallClause({
+    abi: abi2,
+    address,
+    method: method2,
+    args: [user ?? "0x"],
+    queryOptions: {
+      enabled: !!user,
+      select: (data) => data[0]
+    }
+  });
+};
+
+// src/hooks/api/wallet/useRoundXApps.ts
+var abi3 = XAllocationVoting__factory.abi;
+var method3 = "getAppsOfRound";
+var getRoundXAppsQueryKey = (roundId, networkType) => getCallClauseQueryKeyWithArgs({
+  abi: abi3,
+  address: getConfig(networkType).xAllocationVotingContractAddress,
+  method: method3,
+  args: [BigInt(roundId ?? 0)]
+});
+var useRoundXApps = (roundId) => {
+  const { network } = useVeChainKitConfig();
+  const address = getConfig(network.type).xAllocationVotingContractAddress;
+  return useCallClause({
+    abi: abi3,
+    address,
+    method: method3,
+    args: [BigInt(roundId ?? 0)],
+    queryOptions: {
+      enabled: !!roundId,
+      select: (data) => data[0].map((app) => ({
+        id: app.id.toString(),
+        teamWalletAddress: app.teamWalletAddress,
+        name: app.name,
+        metadataURI: app.metadataURI,
+        createdAtTimestamp: app.createdAtTimestamp.toString()
+      }))
+    }
+  });
+};
+var abi4 = XAllocationPool__factory.abi;
+var method4 = "getAppShares";
+var getXAppsSharesQueryKey = (roundId) => [
+  "VECHAIN_KIT",
+  "XApps",
+  "Shares",
+  roundId
+];
+var useXAppsShares = (apps, roundId) => {
+  const thor = useThor();
+  const { network } = useVeChainKitConfig();
+  const address = getConfig(network.type).xAllocationPoolContractAddress;
+  return useQuery({
+    queryKey: getXAppsSharesQueryKey(roundId),
+    queryFn: async () => {
+      const shares = await executeMultipleClausesCall({
+        thor,
+        calls: apps.map(
+          (app) => ({
+            abi: abi4,
+            functionName: method4,
+            address,
+            args: [roundId, app]
+          })
+        )
+      });
+      return shares.map((share, index) => {
+        return {
+          app: apps[index],
+          share: Number(share[0] || 0) / 100,
+          unallocatedShare: Number(share[1] || 0) / 100
+        };
+      });
+    },
+    enabled: !!roundId && !!apps.length
+  });
+};
+
+// src/hooks/api/wallet/useMostVotedAppsInRound.ts
+var useMostVotedAppsInRound = (roundId) => {
+  const { data: apps } = useRoundXApps(roundId);
+  const xAppsShares = useXAppsShares(
+    apps?.map((app) => app.id) ?? [],
+    roundId
+  );
+  const mostVotedApps = useMemo(
+    () => xAppsShares.data?.map((appShares) => ({
+      percentage: appShares.share + appShares.unallocatedShare,
+      id: apps?.find((xa) => xa.id === appShares.app)?.id ?? "",
+      app: apps?.find((xa) => xa.id === appShares.app) ?? {}
+    })).sort((a, b) => Number(b.percentage) - Number(a.percentage)) ?? [],
+    [xAppsShares.data, apps]
+  );
+  return {
+    data: mostVotedApps,
+    isLoading: xAppsShares.isLoading
+  };
+};
 var handlePopupError = ({
   error,
   mobileBrowserPopupMessage = "Mobile browser blocked the window. Please try again.",
@@ -6737,170 +7037,30 @@ var useRefreshBalances = () => {
   };
   return { refresh };
 };
-var getCustomTokenBalances = async (thor, address, customTokens) => {
-  const clauses = customTokens.map((token) => {
-    const erc20Contract = thor.contracts.load(
-      token.address,
-      IERC20__factory.abi
-    );
-    return erc20Contract.clause.balanceOf([address]);
-  });
-  const response = await thor.contracts.executeMultipleClausesCall(clauses);
-  if (!response.every((r) => r.success && !!r.result.plain)) {
-    throw new Error("Failed to get custom token balances");
-  }
-  return response.map((r, index) => {
-    const token = customTokens[index];
-    const original = r.result.plain;
-    const scaled = formatEther$1(BigInt(original)) || "0";
-    return {
-      address: token.address,
-      symbol: token.symbol,
-      balance: scaled
-    };
-  });
-};
-var getTokenBalances = async (thor, address, network) => {
-  const config = getConfig(network);
-  const [b3trBalance, vot3Balance, veDelegateBalance, gloDollarBalance] = await executeMultipleClausesCall({
-    thor,
-    calls: [
-      {
-        abi: IB3TR__factory.abi,
-        address: config.b3trContractAddress,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: IVOT3__factory.abi,
-        address: config.vot3ContractAddress,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: IERC20__factory.abi,
-        address: config.veDelegate,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: IERC20__factory.abi,
-        address: config.gloDollarContractAddress,
-        functionName: "balanceOf",
-        args: [address]
-      }
-    ]
-  });
-  const { balance: vetBalance, energy: vthoBalance } = await getAccountBalance(thor, address);
-  return [
-    {
-      address: "0x",
-      symbol: "VET",
-      balance: vetBalance
-    },
-    {
-      address: config.vthoContractAddress,
-      symbol: "VTHO",
-      balance: vthoBalance
-    },
-    {
-      address: config.b3trContractAddress,
-      symbol: "B3TR",
-      balance: b3trBalance
-    },
-    {
-      address: config.vot3ContractAddress,
-      symbol: "VOT3",
-      balance: vot3Balance
-    },
-    {
-      address: config.veDelegate,
-      symbol: "veDelegate",
-      balance: veDelegateBalance
-    },
-    {
-      address: config.gloDollarContractAddress,
-      symbol: "USDGLO",
-      balance: gloDollarBalance
-    }
-  ];
-};
-var useTokenBalances2 = ({ address }) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  const { customTokens } = useCustomTokens();
-  return useQueries({
-    queries: [
-      {
-        queryKey: ["base-token-balances", address],
-        queryFn: () => getTokenBalances(thor, address, network.type)
-      },
-      {
-        queryKey: ["custom-token-balances", address],
-        queryFn: () => getCustomTokenBalances(thor, address, customTokens)
-      }
-    ],
-    combine: (data) => {
-      return {
-        data: data.flat(),
-        loading: data[0].isLoading || data[1].isLoading,
-        error: data[0].error || data[1].error
-      };
-    }
-  });
-};
-var getTokenPrices = async (thor, tokens2, network) => {
-  const config = getConfig(network);
-  const oracleContract = thor.contracts.load(
-    config.oracleContractAddress,
-    IVechainEnergyOracleV1__factory.abi
-  );
-  const clauses = tokens2.map(
-    (token) => oracleContract.clause.getLatestValue(PRICE_FEED_IDS[token])
-  );
-  const response = await thor.transactions.executeMultipleClausesCall(
-    clauses
-  );
-  if (!response.every((r) => r.success && !!r.result.array)) {
-    throw new Error("Failed to get token prices");
-  }
-  return response.map(
-    (r) => new BigNumber$1((r.result.array?.[0] ?? 0).toString()).div(1e12).toNumber()
+var getXAppMetadata = async (uri, networkType) => {
+  const metadata = await axios.get(
+    convertUriToUrl(uri, networkType) || "",
+    { timeout: 2e4 }
   );
+  return metadata.data;
 };
-var tokens = ["VET", "VTHO", "B3TR", "EUR", "GBP"];
-var useTokenPrices2 = () => {
+var abi5 = X2EarnApps__factory.abi;
+var useXAppMetadata = (xAppId) => {
   const thor = useThor();
   const { network } = useVeChainKitConfig();
-  const config = getConfig(network.type);
   return useQuery({
-    queryKey: ["token-prices", network.type],
-    queryFn: () => getTokenPrices(thor, tokens, network.type),
-    select: (data) => {
-      const [
-        vetUsdPrice,
-        vthoUsdPrice,
-        b3trUsdPrice,
-        eurUsdPrice,
-        gbpUsdPrice
-      ] = data;
-      const prices = {
-        "0x": vetUsdPrice || 0,
-        [config.vthoContractAddress]: vthoUsdPrice || 0,
-        [config.b3trContractAddress]: b3trUsdPrice || 0,
-        [config.vot3ContractAddress]: b3trUsdPrice || 0,
-        [config.veDelegate]: b3trUsdPrice || 0,
-        [config.gloDollarContractAddress]: 1
-        // GloDollar is pegged to USD
-      };
-      const exchangeRates = {
-        eurUsdPrice: eurUsdPrice || 1,
-        gbpUsdPrice: gbpUsdPrice || 1
-      };
-      return {
-        prices,
-        exchangeRates
-      };
+    queryKey: ["xAppMetaData", xAppId],
+    queryFn: async () => {
+      const address = getConfig(network.type).x2EarnAppsContractAddress;
+      const contract = thor.contracts.load(address, abi5);
+      const [app] = await contract.read.app(xAppId);
+      const metadataURI = app?.[3] || "";
+      const [baseUri] = await contract.read.baseURI();
+      const metadata = await getXAppMetadata(
+        `${baseUri}${metadataURI}`,
+        network.type
+      );
+      return metadata;
     }
   });
 };
@@ -7619,8 +7779,8 @@ var ConnectionOptionsStack = () => {
     showMoreLogin,
     isOfficialVeChainApp
   } = useLoginModalContent();
-  return /* @__PURE__ */ jsx(Stack, { spacing: 4, w: "full", align: "center", children: /* @__PURE__ */ jsx(Grid, { templateColumns: "repeat(4, 1fr)", gap: 2, w: "full", children: loginMethods?.map(({ method: method13, gridColumn }) => {
-    switch (method13) {
+  return /* @__PURE__ */ jsx(Stack, { spacing: 4, w: "full", align: "center", children: /* @__PURE__ */ jsx(Grid, { templateColumns: "repeat(4, 1fr)", gap: 2, w: "full", children: loginMethods?.map(({ method: method7, gridColumn }) => {
+    switch (method7) {
       case "email":
         return showEmailLogin && /* @__PURE__ */ jsx(EmailLoginButton, {}, "email");
       case "google":
@@ -7727,7 +7887,7 @@ var MainContent = ({ setCurrentContent, onClose }) => {
     }
   }, [connection.isConnected, onClose]);
   const showEcosystemButton = loginMethods?.some(
-    ({ method: method13 }) => method13 === "ecosystem"
+    ({ method: method7 }) => method7 === "ecosystem"
   );
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsxs(StickyHeaderContainer, { children: [
@@ -13015,13 +13175,13 @@ var PrivyLinkedAccounts = ({ onBack }) => {
   } = usePrivy();
   const canLinkWallets = useMemo(() => {
     const privyWallets = privy?.loginMethods?.filter(
-      (method13) => [
+      (method7) => [
         "rabby_wallet",
         "coinbase_wallet",
         "rainbow",
         "phantom",
         "metamask"
-      ].includes(method13)
+      ].includes(method7)
     ) ?? [];
     const dappKitWallets = dappKit?.allowedWallets ?? [];
     return privyWallets.length > 0 || dappKitWallets.length > 0;
@@ -14165,17 +14325,7 @@ var ExploreEcosystemContent = ({
   ) : [];
   const filteredDefaultApps = DEFAULT_APPS.filter(
     (dapp) => dapp.name.toLowerCase().includes(searchQuery.toLowerCase())
-  ).map((dapp) => {
-    if (dapp.logoComponent) {
-      return {
-        ...dapp,
-        logoComponent: React10.cloneElement(dapp.logoComponent, {
-          isDark
-        })
-      };
-    }
-    return dapp;
-  });
+  );
   const filteredAppHubApps = appHubApps?.filter(
     (app) => (
       // Text search filter
@@ -14262,10 +14412,7 @@ var ExploreEcosystemContent = ({
             url: dapp.external_url,
             setCurrentContent,
             description: dapp.description,
-            selectedCategory: currentCategory,
-            ...dapp.logoComponent && {
-              logoComponent: dapp.logoComponent
-            }
+            selectedCategory: currentCategory
           }
         ) }, dapp.name)) }),
         shouldShowVbdApps && filteredVbdApps.length > 0 && /* @__PURE__ */ jsx(Fragment, { children: filteredVbdApps.map((dapp) => /* @__PURE__ */ jsx(GridItem, { children: /* @__PURE__ */ jsx(
@@ -15014,7 +15161,7 @@ var ConnectPopover = ({
     privyEcosystemAppIDS
   } = useVeChainKitConfig();
   const showEcosystemButton = loginMethods?.some(
-    ({ method: method13 }) => method13 === "ecosystem"
+    ({ method: method7 }) => method7 === "ecosystem"
   );
   const { data: appsInfo, isLoading: isEcosystemAppsLoading } = useFetchAppInfo(privyEcosystemAppIDS);
   return /* @__PURE__ */ jsx(
@@ -16557,14 +16704,14 @@ var ReceiveModalProvider = ({ children }) => /* @__PURE__ */ jsx(Fragment, { chi
 var useLoginModalContent = () => {
   const { privy, loginMethods } = useVeChainKitConfig();
   const isVeChainApp = privy?.appId === VECHAIN_PRIVY_APP_ID;
-  const isLoginMethodEnabled = (method13) => {
+  const isLoginMethodEnabled = (method7) => {
     if (!loginMethods) return true;
-    if (Array.isArray(method13)) {
-      return method13.some(
+    if (Array.isArray(method7)) {
+      return method7.some(
         (m) => loginMethods.some((lm) => lm.method === m)
       );
     }
-    return loginMethods.some((lm) => lm.method === method13);
+    return loginMethods.some((lm) => lm.method === method7);
   };
   const showEcosystemLogin = useMemo(() => {
     if (!loginMethods) return true;
@@ -16988,24 +17135,24 @@ var getCallClauseQueryKey = ({
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   abi: abi9,
   address,
-  method: method13
-}) => ["callClause", address, method13];
+  method: method7
+}) => ["callClause", address, method7];
 var getCallClauseQueryKeyWithArgs = ({
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   abi: abi9,
   address,
-  method: method13,
+  method: method7,
   args
 }) => [
   "callClause",
   address,
-  method13,
+  method7,
   ...args?.length ? [args] : []
 ];
 var useCallClause = ({
   address,
   abi: abi9,
-  method: method13,
+  method: method7,
   args,
   queryOptions
 }) => {
@@ -17014,14 +17161,14 @@ var useCallClause = ({
     queryKey: getCallClauseQueryKeyWithArgs({
       abi: abi9,
       address,
-      method: method13,
+      method: method7,
       args
     }),
     queryFn: async () => executeCallClause({
       thor,
       contractAddress: address,
       abi: abi9,
-      method: method13,
+      method: method7,
       args
     }),
     ...queryOptions
@@ -17143,8 +17290,8 @@ var getAccountBalance = async (thor, address) => {
   if (!address) throw new Error("Address is required");
   const account = await thor.accounts.getAccount(Address.of(address));
   return {
-    balance: formatEther(BigInt(account.balance)).toString(),
-    energy: formatEther(BigInt(account.energy)).toString()
+    balance: formatEther$1(BigInt(account.balance)).toString(),
+    energy: formatEther$1(BigInt(account.energy)).toString()
   };
 };
 var getAccountBalanceQueryKey = (address) => [
@@ -17259,9 +17406,9 @@ var useGetAccountAddress = (ownerAddress) => {
 };
 
 // src/hooks/thor/smartAccounts/useGetAccountVersion.ts
-var abi = SimpleAccountFactory__factory.abi;
+var abi6 = SimpleAccountFactory__factory.abi;
 var getAccountVersionQueryKey = (accountAddress, ownerAddress, networkType) => getCallClauseQueryKeyWithArgs({
-  abi,
+  abi: abi6,
   address: getConfig(networkType).accountFactoryAddress,
   method: "getAccountVersion",
   args: [accountAddress, ownerAddress]
@@ -17270,7 +17417,7 @@ var useGetAccountVersion = (accountAddress, ownerAddress) => {
   const { network } = useVeChainKitConfig();
   return useCallClause({
     address: getConfig(network.type).accountFactoryAddress,
-    abi,
+    abi: abi6,
     method: "getAccountVersion",
     args: [accountAddress, ownerAddress],
     queryOptions: {
@@ -17283,16 +17430,16 @@ var useGetAccountVersion = (accountAddress, ownerAddress) => {
     }
   });
 };
-var abi2 = SimpleAccountFactory__factory.abi;
-var method = "hasLegacyAccount";
+var abi7 = SimpleAccountFactory__factory.abi;
+var method5 = "hasLegacyAccount";
 var getHasV1SmartAccount = async (thor, ownerAddress, networkType) => {
   if (!ownerAddress) throw new Error("Owner address is required");
   if (!networkType) throw new Error("Network type is required");
   const [hasLegacyAccount] = await executeCallClause({
     thor,
-    abi: abi2,
+    abi: abi7,
     contractAddress: getConfig(networkType).accountFactoryAddress,
-    method,
+    method: method5,
     args: [ownerAddress]
   });
   return hasLegacyAccount;
@@ -17503,15 +17650,15 @@ var useSmartAccount = (ownerAddress) => {
     enabled: !!ownerAddress && !!network.type && !!thor
   });
 };
-var abi3 = SimpleAccountFactory__factory.abi;
-var method2 = "version";
+var abi8 = SimpleAccountFactory__factory.abi;
+var method6 = "version";
 var getVersion = async (thor, contractAddress) => {
   if (!contractAddress) throw new Error("Contract address is required");
   const [version] = await executeCallClause({
     thor,
     contractAddress,
-    abi: abi3,
-    method: method2,
+    abi: abi8,
+    method: method6,
     args: []
   });
   return Number(version);
@@ -17699,1165 +17846,76 @@ var useGetChainId = () => {
     refetchInterval: 1e4
   });
 };
-var getB3trBalance = async (thor, network, address) => {
-  const res = await thor.contracts.load(getConfig(network).b3trContractAddress, B3TR__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error("Failed to get b3tr balance");
-  const original = res[0].toString();
-  const scaled = formatEther$1(original);
-  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getB3trBalanceQueryKey = (address) => [
-  "VEBETTERDAO_BALANCE",
-  address,
-  "B3TR"
-];
-var useGetB3trBalance = (address) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getB3trBalanceQueryKey(address),
-    queryFn: async () => getB3trBalance(thor, network.type, address),
-    enabled: !!thor && !!address && !!network.type
-  });
-};
-var getCustomTokenBalance = async (thor, token, address) => {
-  const res = await thor.contracts.load(token.address, ERC20__factory.abi).read.balanceOf([address]);
-  if (!res) throw new Error(`Failed to get balance of ${token.address}`);
-  const original = res[0];
-  const scaled = formatEther(BigInt(original));
-  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
-  return {
-    ...token,
-    original: original.toString(),
-    scaled,
-    formatted
-  };
-};
-var getCustomTokenBalanceQueryKey = (tokenAddress, address) => ["VECHAIN_KIT_BALANCE", address, "CUSTOM_TOKEN", tokenAddress];
-var useGetCustomTokenBalances = (address) => {
-  const thor = useThor();
-  const { customTokens } = useCustomTokens();
-  return useQueries({
-    queries: customTokens.map((token) => ({
-      queryKey: getCustomTokenBalanceQueryKey(token.address, address),
-      queryFn: async () => {
-        return await getCustomTokenBalance(thor, token, address);
-      }
-    }))
+
+// src/hooks/thor/logs/logUtils.ts
+var MAX_EVENTS_PER_QUERY = 1e3;
+var getEventLogs = async ({
+  thor,
+  order = "asc",
+  offset = 0,
+  limit = MAX_EVENTS_PER_QUERY,
+  from = 0,
+  to = thor.blocks.getHeadBlock()?.number,
+  filterCriteria
+}) => {
+  const response = await thor.logs.filterEventLogs({
+    range: {
+      from,
+      to,
+      unit: "block"
+    },
+    options: {
+      offset,
+      limit
+    },
+    order,
+    criteriaSet: filterCriteria
   });
+  if (!response) throw new Error("Failed to fetch events");
+  return response;
 };
-var getTokenInfo = async (thor, tokenAddress) => {
-  if (!tokenAddress) throw new Error("Token address is required");
-  const contract = thor.contracts.load(tokenAddress, ERC20__factory.abi);
-  const response = await thor.contracts.executeMultipleClausesCall([
-    contract.clause.name(),
-    contract.clause.symbol(),
-    contract.clause.decimals()
-  ]);
-  if (response.every((r) => r.success) === false) {
-    throw new Error(`Failed to get token info of ${tokenAddress}`);
+var getAllEventLogs = async ({
+  nodeUrl,
+  thor,
+  order = "asc",
+  from = 0,
+  to,
+  filterCriteria
+}) => {
+  const allEvents = [];
+  let offset = 0;
+  while (true) {
+    const events = await getEventLogs({
+      thor,
+      filterCriteria,
+      from,
+      to: to ?? Number.MAX_SAFE_INTEGER,
+      limit: MAX_EVENTS_PER_QUERY,
+      order,
+      offset
+    });
+    allEvents.push(...events);
+    if (events.length < MAX_EVENTS_PER_QUERY) {
+      return allEvents;
+    }
+    offset += MAX_EVENTS_PER_QUERY;
   }
-  const [name, symbol, decimals] = response.map((res) => {
-    return res.result.array?.[0];
-  });
-  return {
-    name,
-    address: tokenAddress,
-    decimals,
-    symbol
-  };
-};
-var getCustomTokenInfo = (tokenAddress) => [
-  "VECHAIN_KIT_CUSTOM_TOKEN_BALANCE",
-  tokenAddress
-];
-var useGetCustomTokenInfo = (tokenAddress) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getCustomTokenInfo(tokenAddress),
-    queryFn: async () => getTokenInfo(thor, tokenAddress),
-    enabled: !!thor && !!network.type && !!tokenAddress
-  });
 };
-var getErc20Balance = async (thor, tokenAddress, address) => {
-  if (!tokenAddress || !address) {
-    throw new Error("Token address and user address are required");
-  }
-  const res = await thor.contracts.load(tokenAddress, IERC20__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error(`Failed to get balance of ${tokenAddress}`);
-  const original = res[0].toString();
-  const scaled = formatEther$1(original);
-  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
+
+// src/hooks/thor/transactions/transactionUtils.ts
+var estimateTxGas = async (thor, clauses, caller) => {
+  const response = await thor.transactions.estimateGas(clauses, caller);
+  if (response.reverted) throw new Error("Failed to estimate gas");
+  return response.totalGas;
 };
-var getErc20BalanceQueryKey = (tokenAddress, address) => ["VECHAIN_KIT", "BALANCE", "ERC20", tokenAddress, address];
-var useGetErc20Balance = (tokenAddress, address) => {
-  const thor = useThor();
-  return useQuery({
-    queryKey: getErc20BalanceQueryKey(tokenAddress, address),
-    queryFn: async () => getErc20Balance(thor, tokenAddress, address),
-    enabled: !!thor && !!address && !!tokenAddress
-  });
-};
-var getVeDelegateBalance = async (thor, network, address) => {
-  const res = await thor.contracts.load(
-    getConfig(network).veDelegateTokenContractAddress,
-    IERC20__factory.abi
-  ).read.balanceOf(address);
-  if (!res)
-    throw new Error(`Failed to get veDelegate balance for ${address}`);
-  const original = res[0].toString();
-  const scaled = formatEther$1(original);
-  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getVeDelegateBalanceQueryKey = (address) => [
-  "VECHAIN_KIT_BALANCE",
-  address,
-  "VE_DELEGATE"
-];
-var useGetVeDelegateBalance = (address) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getVeDelegateBalanceQueryKey(address),
-    queryFn: async () => getVeDelegateBalance(thor, network.type, address),
-    enabled: !!thor && !!address && !!network.type
-  });
-};
-var getTokensInfoByOwnerQueryKey = (owner) => [
-  "VECHAIN_KIT_GALAXY_MEMBER_TOKENS_INFO",
-  owner
-];
-var useGalaxyMemberTokensInfo = (owner, size = 10) => {
-  const { network } = useVeChainKitConfig();
-  const contractAddress = getConfig(network.type).galaxyMemberContractAddress;
-  const thor = useThor();
-  const fetchTokens = async ({ pageParam = 0 }) => {
-    const data = await thor.contracts.load(contractAddress, GalaxyMember__factory.abi).read.getTokensInfoByOwner(owner, pageParam, size);
-    if (!data)
-      throw new Error(
-        `Failed to fetch tokens info for page ${pageParam}`
-      );
-    return { data, nextPage: pageParam + 1 };
-  };
-  return useInfiniteQuery({
-    queryKey: getTokensInfoByOwnerQueryKey(owner),
-    queryFn: fetchTokens,
-    getNextPageParam: (lastPage) => lastPage.data.length === size ? lastPage.nextPage : void 0,
-    enabled: !!owner && !!network.type,
-    initialPageParam: 0
-  });
-};
-
-// src/hooks/thor/contracts/NodeManagement/useGetUserNodes.ts
-var contractAbi = NodeManagement__factory.abi;
-var method3 = "getUserNodes";
-var getUserNodesQueryKey = (networkType, user) => getCallClauseQueryKeyWithArgs({
-  abi: contractAbi,
-  address: getConfig(networkType).nodeManagementContractAddress,
-  method: method3,
-  args: [user]
-});
-var useGetUserNodes = (userInput) => {
-  const { network } = useVeChainKitConfig();
-  const contractAddress = getConfig(
-    network.type
-  ).nodeManagementContractAddress;
-  return useCallClause({
-    address: contractAddress,
-    abi: contractAbi,
-    method: method3,
-    args: [userInput],
-    queryOptions: {
-      enabled: !!userInput && !!network.type && !!contractAddress,
-      select: (response) => {
-        return response[0].map((node) => ({
-          nodeId: node.nodeId.toString(),
-          nodeLevel: Number(node.nodeLevel),
-          xNodeOwner: node.xNodeOwner,
-          isXNodeHolder: node.isXNodeHolder,
-          isXNodeDelegated: node.isXNodeDelegated,
-          isXNodeDelegator: node.isXNodeDelegator,
-          isXNodeDelegatee: node.isXNodeDelegatee,
-          delegatee: node.delegatee
-        }));
-      }
-    }
-  });
-};
-var useGetUserNode = useGetUserNodes;
-var PRICE_FEED_IDS = {
-  B3TR: "0x623374722d757364000000000000000000000000000000000000000000000000",
-  VET: "0x7665742d75736400000000000000000000000000000000000000000000000000",
-  VTHO: "0x7674686f2d757364000000000000000000000000000000000000000000000000",
-  GBP: "0x6762702d75736400000000000000000000000000000000000000000000000000",
-  EUR: "0x657572742d757364000000000000000000000000000000000000000000000000"
-};
-var getTokenUsdPrice = async (thor, token, network) => {
-  const res = await thor.contracts.load(
-    getConfig(network).oracleContractAddress,
-    IVechainEnergyOracleV1__factory.abi
-  ).read.getLatestValue(PRICE_FEED_IDS[token]);
-  if (!res) throw new Error(`Failed to get price of ${token}`);
-  return new BigNumber(res[0].toString()).div(1e12).toNumber();
-};
-var getTokenUsdPriceQueryKey = (token) => [
-  "VECHAIN_KIT_PRICE",
-  token
-];
-var useGetTokenUsdPrice = (token) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getTokenUsdPriceQueryKey(token),
-    queryFn: async () => getTokenUsdPrice(thor, token, network.type),
-    enabled: !!thor && !!network.type
-  });
-};
-var getVot3Balance = async (thor, network, address) => {
-  const res = await thor.contracts.load(getConfig(network).vot3ContractAddress, VOT3__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error("Reverted");
-  const original = res[0].toString();
-  const scaled = formatEther$1(original);
-  const formatted = scaled === "0" ? "0" : humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getVot3BalanceQueryKey = (address) => [
-  "VEBETTERDAO_BALANCE",
-  address,
-  "VOT3"
-];
-var useGetVot3Balance = (address) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getVot3BalanceQueryKey(address || ""),
-    queryFn: async () => getVot3Balance(thor, network.type, address),
-    enabled: !!thor && !!address && !!network.type
-  });
-};
-var contractAbi2 = VeBetterPassport__factory.abi;
-var method4 = "isPerson";
-var getIsPersonQueryKey = (networkType, user) => {
-  const veBetterPassportContractAddress = getConfig(networkType).veBetterPassportContractAddress;
-  return getCallClauseQueryKeyWithArgs({
-    abi: contractAbi2,
-    address: veBetterPassportContractAddress,
-    method: method4,
-    args: [user]
-  });
-};
-var useIsPerson = (user, customEnabled = true) => {
-  const { network } = useVeChainKitConfig();
-  const veBetterPassportContractAddress = getConfig(
-    network.type
-  ).veBetterPassportContractAddress;
-  return useCallClause({
-    abi: contractAbi2,
-    address: veBetterPassportContractAddress,
-    method: method4,
-    args: [user ?? ZERO_ADDRESS],
-    queryOptions: {
-      enabled: !!user && customEnabled && !!veBetterPassportContractAddress && !!network.type,
-      select: (data) => data[0]
-    }
-  });
-};
-var useIsUserPerson = (address) => {
-  return useIsPerson(address);
-};
-var contractAbi3 = VeBetterPassport__factory.abi;
-var method5 = "isPersonAtTimepoint";
-var getIsPersonAtTimepointQueryKey = (networkType, user, timepoint) => {
-  const veBetterPassportContractAddress = getConfig(networkType).veBetterPassportContractAddress;
-  return getCallClauseQueryKeyWithArgs({
-    abi: contractAbi3,
-    address: veBetterPassportContractAddress,
-    method: method5,
-    args: [user, Number(timepoint)]
-  });
-};
-var useIsPersonAtTimepoint = (user, timepoint, customEnabled = true) => {
-  const { network } = useVeChainKitConfig();
-  const veBetterPassportContractAddress = getConfig(
-    network.type
-  ).veBetterPassportContractAddress;
-  return useCallClause({
-    abi: contractAbi3,
-    address: veBetterPassportContractAddress,
-    method: method5,
-    args: [
-      user ?? ZERO_ADDRESS,
-      timepoint ? Number(timepoint) : 0
-    ],
-    queryOptions: {
-      enabled: !!user && timepoint !== void 0 && customEnabled && !!veBetterPassportContractAddress && !!network.type,
-      select: (data) => data[0]
-    }
-  });
-};
-
-// src/hooks/thor/contracts/VeBetterPassport/useUserBotSignals.ts
-var contractAbi4 = VeBetterPassport__factory.abi;
-var method6 = "signaledCounter";
-var getUserBotSignalsQueryKey = (networkType, userAddress) => {
-  return getCallClauseQueryKeyWithArgs({
-    abi: contractAbi4,
-    address: getConfig(networkType).veBetterPassportContractAddress,
-    method: method6,
-    args: [userAddress]
-  });
-};
-var useUserBotSignals = (userAddressInput) => {
-  const { network } = useVeChainKitConfig();
-  const veBetterPassportContractAddress = getConfig(
-    network.type
-  ).veBetterPassportContractAddress;
-  return useCallClause({
-    address: veBetterPassportContractAddress,
-    abi: contractAbi4,
-    method: method6,
-    args: [userAddressInput],
-    queryOptions: {
-      enabled: !!userAddressInput && !!veBetterPassportContractAddress && !!network.type,
-      select: (res) => Number(res[0])
-    }
-  });
-};
-var useVotingRewards = (currentRoundId, voter) => {
-  const thor = useThor();
-  const queryClient = useQueryClient();
-  const { network } = useVeChainKitConfig();
-  const contractAddress = getConfig(network.type).voterRewardsContractAddress;
-  const rounds = useMemo(() => {
-    return Array.from(
-      { length: parseInt(currentRoundId ?? "0") - 1 },
-      (_, i) => (i + 1).toString()
-    );
-  }, [currentRoundId]);
-  return useQuery({
-    queryKey: getRoundRewardQueryKey("ALL", voter),
-    enabled: !!thor && !!voter && !!currentRoundId && !!rounds.length && !!network.type,
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        contractAddress,
-        VoterRewards__factory.abi
-      );
-      const clauses = rounds.map(
-        (roundId) => (
-          // Voter Rewards getReward result type: [ 0n ]
-          contract.clause.getReward(roundId, voter)
-        )
-      );
-      const res = await thor.transactions.executeMultipleClausesCall(
-        clauses
-      );
-      if (!res.every((r) => r.success))
-        throw new Error("Failed to fetch voting rewards");
-      let total = new BigNumber(0);
-      const roundsRewards = res.map((r, index) => {
-        const roundId = rounds[index];
-        const rewards = r.result.plain;
-        const formattedRewards = formatEther(rewards);
-        total = total.plus(BigNumber(rewards.toString()));
-        queryClient.setQueryData(
-          getRoundRewardQueryKey(roundId, voter),
-          {
-            roundId,
-            rewards: formattedRewards
-          }
-        );
-        return {
-          roundId,
-          rewards,
-          formattedRewards
-        };
-      });
-      const totalFormatted = formatEther(BigInt(total.toFixed()));
-      return {
-        total: total.toFixed(),
-        totalFormatted,
-        roundsRewards
-      };
-    }
-  });
-};
-var getRoundRewardQueryKey = (roundId, address) => [
-  "VECHAIN_KIT",
-  "roundReward",
-  roundId,
-  "voter",
-  address
-];
-var useRoundReward = (address, roundId) => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    address: getConfig(network.type).voterRewardsContractAddress,
-    abi: VoterRewards__factory.abi,
-    method: "getReward",
-    args: [BigInt(roundId || 0), address],
-    queryOptions: {
-      enabled: !!address && !!roundId && !!network.type,
-      select: (data) => ({
-        roundId,
-        rewards: formatEther(BigInt(data[0]))
-      })
-    }
-  });
-};
-
-// src/hooks/thor/contracts/X2EarnApps/utils/getXAppMetadata.ts
-var getXAppMetadata = async (uri, networkType) => {
-  const url = convertUriToUrl(uri, networkType);
-  if (!url) return void 0;
-  const response = await fetch(url);
-  if (!response.ok) {
-    return void 0;
-  }
-  return response.json();
-};
-
-// src/hooks/thor/contracts/X2EarnApps/utils/getXApps.ts
-var getXApps = async (thor, networkType) => {
-  const contract = thor.contracts.load(
-    getConfig(networkType).x2EarnAppsContractAddress,
-    X2EarnApps__factory.abi
-  );
-  const clauses = [contract.clause.unendorsedApps(), contract.clause.apps()];
-  const res = await thor.transactions.executeMultipleClausesCall(clauses);
-  if (!res.every((r) => r.success)) throw new Error(`Failed to fetch xApps`);
-  const apps = res[0]?.result.plain;
-  const unendorsedApps = res[1]?.result.plain;
-  const allApps = {};
-  for (const app of apps) {
-    allApps[app.id] = {
-      id: app.id,
-      teamWalletAddress: app.teamWalletAddress,
-      name: app.name,
-      metadataURI: app.metadataURI,
-      createdAtTimestamp: app.createdAtTimestamp.toString()
-    };
-  }
-  for (const app of unendorsedApps) {
-    allApps[app.id] = {
-      id: app.id,
-      teamWalletAddress: app.teamWalletAddress,
-      name: app.name,
-      metadataURI: app.metadataURI,
-      createdAtTimestamp: app.createdAtTimestamp.toString(),
-      appAvailableForAllocationVoting: app.appAvailableForAllocationVoting
-    };
-  }
-  const unendorsedIds = new Set(unendorsedApps.map((app) => app.id));
-  return {
-    allApps: Object.values(allApps),
-    active: apps.map((app) => ({
-      ...app,
-      createdAtTimestamp: app.createdAtTimestamp.toString()
-    })),
-    unendorsed: unendorsedApps.map((app) => ({
-      ...app,
-      createdAtTimestamp: app.createdAtTimestamp.toString()
-    })),
-    endorsed: apps.filter((app) => !unendorsedIds.has(app.id)).map((app) => ({
-      ...app,
-      createdAtTimestamp: app.createdAtTimestamp.toString()
-    }))
-  };
-};
-var abi4 = XAllocationVoting__factory.abi;
-var method7 = "getAppsOfRound";
-var getRoundXApps = async (thor, networkType, roundId) => {
-  if (!roundId) return [];
-  const [xApps] = await executeCallClause({
-    thor,
-    contractAddress: getConfig(networkType).xAllocationVotingContractAddress,
-    abi: abi4,
-    method: method7,
-    args: [BigInt(roundId)]
-  });
-  return xApps.map((app) => ({
-    id: app.id.toString(),
-    teamWalletAddress: app.teamWalletAddress,
-    name: app.name,
-    metadataURI: app.metadataURI,
-    createdAtTimestamp: app.createdAtTimestamp.toString(),
-    appAvailableForAllocationVoting: app.appAvailableForAllocationVoting
-  }));
-};
-var getRoundXAppsQueryKey = (roundId) => [
-  "VECHAIN_KIT",
-  "round",
-  roundId,
-  "getXApps"
-];
-var useRoundXApps = (roundId) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getRoundXAppsQueryKey(roundId),
-    queryFn: async () => await getRoundXApps(thor, network.type, roundId),
-    enabled: !!thor && !!roundId && !!network.type
-  });
-};
-var getUserVotesInRound = async (thor, network, roundId, address) => {
-  const xAllocationVotingContract = getConfig(network).xAllocationVotingContractAddress;
-  const eventAbi = thor.contracts.load(xAllocationVotingContract, XAllocationVoting__factory.abi).getEventAbi("AllocationVoteCast");
-  const topics = eventAbi.encodeFilterTopicsNoNull({
-    ...address ? { voter: address } : {},
-    ...roundId ? { roundId } : {}
-  });
-  const filterCriteria = [
-    {
-      criteria: {
-        address: xAllocationVotingContract,
-        topic0: topics[0] ?? void 0,
-        topic1: topics[1] ?? void 0,
-        topic2: topics[2] ?? void 0,
-        topic3: topics[3] ?? void 0,
-        topic4: topics[4] ?? void 0
-      },
-      eventAbi
-    }
-  ];
-  const events = await getAllEventLogs({
-    thor,
-    filterCriteria,
-    nodeUrl: getConfig(network).nodeUrl
-  });
-  const decodedAllocatedVoteEvents = [];
-  events.forEach((event) => {
-    if (!event.decodedData) {
-      throw new Error("Event data not decoded");
-    }
-    if (!compareAddresses(event.address, xAllocationVotingContract)) {
-      throw new Error("Event address not valid");
-    }
-    const [voter, roundId2, appsIds, voteWeights] = event.decodedData;
-    decodedAllocatedVoteEvents.push({
-      voter,
-      roundId: roundId2,
-      appsIds,
-      voteWeights
-    });
-  });
-  return decodedAllocatedVoteEvents;
-};
-var getUserVotesInRoundQueryKey = (roundId, address) => [
-  "VECHAIN_KIT",
-  "allocationsRound",
-  roundId,
-  "userVotes",
-  ...address ? [address] : []
-];
-var useUserVotesInRound = (roundId, address) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getUserVotesInRoundQueryKey(roundId, address),
-    queryFn: async () => {
-      const votes = await getUserVotesInRound(
-        thor,
-        network.type,
-        roundId,
-        address
-      );
-      if (votes.length > 1) throw new Error("More than one event found");
-      if (votes.length === 0) throw new Error("No event found");
-      return votes[0];
-    },
-    enabled: !!thor && !!thor.blocks.getHeadBlock() && !!roundId && !!address && !!network.type
-  });
-};
-var getVotesInRoundQueryKey = (roundId) => [
-  "VECHAIN_KIT",
-  "allocationsRound",
-  roundId,
-  "totalVotes"
-];
-var useVotesInRound = (roundId, enabled = true) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getVotesInRoundQueryKey(roundId),
-    queryFn: async () => await getUserVotesInRound(thor, network.type, roundId),
-    enabled: !!thor && !!thor.blocks.getHeadBlock() && !!roundId && enabled && !!network.type
-  });
-};
-var getXAppsQueryKey = () => ["VECHAIN_KIT", "getXApps"];
-var useXApps = () => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getXAppsQueryKey(),
-    queryFn: async () => await getXApps(thor, network.type),
-    enabled: !!thor && !!network.type
-  });
-};
-
-// src/hooks/thor/contracts/X2EarnApps/custom/useXApp.ts
-var useXApp = (appId) => {
-  const { data: xApps, ...props } = useXApps();
-  const allApps = useMemo(() => [...xApps?.active ?? [], ...xApps?.unendorsed ?? []], [xApps]);
-  const app = allApps.find((xa) => xa.id === appId);
-  return {
-    data: app,
-    ...props
-  };
-};
-var getXAppMetadataQueryKey = (metadataURI) => [
-  "VECHAIN_KIT",
-  "xApps",
-  metadataURI,
-  "metadata"
-];
-var useXAppMetadata = (xAppId) => {
-  const { data: baseUri } = useXAppsMetadataBaseUri();
-  const { data: xApp } = useXApp(xAppId ?? "");
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getXAppMetadataQueryKey(xApp?.metadataURI || ""),
-    queryFn: async () => !(!baseUri && xApp) ? await getXAppMetadata(
-      `${baseUri}${xApp?.metadataURI}`,
-      network.type
-    ) : null,
-    enabled: !!baseUri && !!xApp && !!network.type
-  });
-};
-var getXAppsSharesQueryKey = (roundId) => [
-  "VECHAIN_KIT",
-  "XApps",
-  "Shares",
-  roundId
-];
-var useXAppsShares = (apps, roundId) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getXAppsSharesQueryKey(roundId),
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        getConfig(network.type).xAllocationPoolContractAddress,
-        XAllocationPool__factory.abi
-      );
-      const clauses = apps.map(
-        (app) => contract.clause.getAppShares(roundId, app)
-      );
-      const res = await thor.transactions.executeMultipleClausesCall(
-        clauses
-      );
-      if (!res.every((r) => r.success))
-        throw new Error(
-          `Failed to fetch xApps shares for ${apps} in round ${roundId}`
-        );
-      const shares = res.map((r, index) => {
-        return {
-          app: apps[index],
-          share: Number(r.result.array?.[0] || 0) / 100,
-          unallocatedShare: Number(r.result.array?.[1] || 0) / 100
-        };
-      });
-      return shares;
-    },
-    enabled: !!roundId && !!apps.length
-  });
-};
-
-// src/hooks/thor/contracts/X2EarnApps/custom/useMostVotedAppsInRound.ts
-var useMostVotedAppsInRound = (roundId) => {
-  const { data: roundXApps } = useRoundXApps(roundId);
-  const { data: allXApps } = useXApps();
-  const apps = roundId === "0" ? allXApps?.active : roundXApps;
-  const xAppsShares = useXAppsShares(
-    apps?.map((app) => app.id) ?? [],
-    roundId
-  );
-  const mostVotedApps = useMemo(
-    () => xAppsShares.data?.map((appShares) => ({
-      percentage: appShares.share + appShares.unallocatedShare,
-      id: apps?.find((xa) => xa.id === appShares.app)?.id ?? "",
-      app: apps?.find((xa) => xa.id === appShares.app) ?? {}
-    })).sort((a, b) => Number(b.percentage) - Number(a.percentage)) ?? [],
-    [xAppsShares.data, apps]
-  );
-  return {
-    data: mostVotedApps,
-    isLoading: xAppsShares.isLoading
-  };
-};
-
-// src/hooks/thor/contracts/X2EarnApps/useXAppsMetadataBaseUri.ts
-var abi5 = X2EarnApps__factory.abi;
-var method8 = "baseURI";
-var getXAppsMetadataBaseUriQueryKey = (network) => getCallClauseQueryKeyWithArgs({
-  abi: abi5,
-  method: method8,
-  address: getConfig(network).x2EarnAppsContractAddress,
-  args: []
-});
-var useXAppsMetadataBaseUri = () => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi5,
-    address: getConfig(network.type).x2EarnAppsContractAddress,
-    method: method8,
-    args: [],
-    queryOptions: {
-      enabled: !!network.type,
-      staleTime: 1e3 * 60 * 60
-      // 1 hour,
-    }
-  });
-};
-var getXAppRoundEarnings = async (thor, roundId, xAppId, networkType) => {
-  const res = await thor.contracts.load(
-    getConfig(networkType).xAllocationPoolContractAddress,
-    XAllocationPool__factory.abi
-  ).read.roundEarnings(roundId, xAppId);
-  if (!res)
-    throw new Error(
-      `Failed to fetch xApp round earnings for ${xAppId} in round ${roundId}`
-    );
-  return { amount: formatEther(BigInt(res[0] || 0)), appId: xAppId };
-};
-var getXAppRoundEarningsQueryKey = (roundId, xAppId) => [
-  "VECHAIN_KIT",
-  "roundEarnings",
-  "roundId",
-  Number(roundId),
-  "appId",
-  ...xAppId ? [xAppId] : []
-];
-var useXAppRoundEarnings = (roundId, xAppId) => {
-  const thor = useThor();
-  const queryClient = getOrCreateQueryClient();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getXAppRoundEarningsQueryKey(roundId, xAppId),
-    queryFn: async () => {
-      const data = await queryClient.ensureQueryData({
-        queryFn: () => getRoundXApps(thor, network.type, roundId),
-        queryKey: getRoundXAppsQueryKey(roundId)
-      });
-      const isXAppInRound = data.some((app) => app.id === xAppId);
-      if (!isXAppInRound) return { amount: "0", xAppId };
-      return await getXAppRoundEarnings(
-        thor,
-        roundId,
-        xAppId,
-        network.type
-      );
-    },
-    enabled: !!thor && !!roundId && !!xAppId
-  });
-};
-var useMultipleXAppRoundEarnings = (roundId, xAppIds) => {
-  const thor = useThor();
-  const queryClient = getOrCreateQueryClient();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getXAppRoundEarningsQueryKey(roundId, "ALL"),
-    queryFn: async () => {
-      const data = await queryClient.ensureQueryData({
-        queryFn: () => getRoundXApps(thor, network.type, roundId),
-        queryKey: getRoundXAppsQueryKey(roundId)
-      });
-      const xAllocationPoolContract = getConfig(
-        network.type
-      ).xAllocationPoolContractAddress;
-      const xAppsInRound = data.filter((app) => xAppIds.includes(app.id));
-      const contract = thor.contracts.load(
-        xAllocationPoolContract,
-        XAllocationPool__factory.abi
-      );
-      const clauses = xAppsInRound.map(
-        (app) => contract.clause.roundEarnings(roundId, app.id)
-      );
-      const res = await thor.transactions.executeMultipleClausesCall(
-        clauses
-      );
-      if (!res.every((r) => r.success))
-        throw new Error("Failed to fetch xApp round earnings");
-      const decoded = res.map((earnings, index) => {
-        const parsedAmount = formatEther(
-          earnings.result.plain
-        );
-        const appId = xAppsInRound[index]?.id;
-        queryClient.setQueryData(
-          getXAppRoundEarningsQueryKey(roundId, appId),
-          {
-            amount: parsedAmount,
-            appId
-          }
-        );
-        return { amount: parsedAmount, appId };
-      });
-      return decoded;
-    },
-    enabled: !!thor && !!roundId && !!xAppIds.length
-  });
-};
-var getXAppTotalEarningsQueryKey = (tillRoundId, appId) => [
-  "VECHAIN_KIT",
-  "XAllocationPool",
-  "xApp",
-  appId,
-  "totalEarningsTillRound",
-  tillRoundId
-];
-var useXAppTotalEarnings = (roundIds, appId) => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  const queryClient = getOrCreateQueryClient();
-  const lastRound = roundIds[roundIds.length - 1] ?? 0;
-  return useQuery({
-    queryKey: getXAppTotalEarningsQueryKey(lastRound, appId),
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        getConfig(network.type).xAllocationPoolContractAddress,
-        XAllocationPool__factory.abi
-      );
-      const clauses = roundIds.map(
-        (roundId) => contract.clause.roundEarnings(roundId, appId)
-      );
-      const res = await thor.transactions.executeMultipleClausesCall(
-        clauses
-      );
-      if (!res.every((r) => r.success))
-        throw new Error(
-          `Failed to fetch xApp total earnings of ${appId}`
-        );
-      const decoded = res.map((r, index) => {
-        const parsedAmount = formatEther(
-          r.result.plain || BigInt(0)
-        );
-        queryClient.setQueryData(
-          getXAppRoundEarningsQueryKey(
-            roundIds[index],
-            appId
-          ),
-          {
-            amount: parsedAmount,
-            appId
-          }
-        );
-        return parsedAmount;
-      });
-      return decoded.reduce((acc, amount) => {
-        return acc + Number(amount);
-      }, 0);
-    }
-  });
-};
-
-// src/hooks/thor/contracts/XAllocationVoting/useAllocationsRoundState.ts
-var RoundState = {
-  0: "Active",
-  1: "Failed",
-  2: "Succeeded"
-};
-var abi6 = XAllocationVoting__factory.abi;
-var method9 = "state";
-var getAllocationsRoundStateQueryKey = (roundId, network) => getCallClauseQueryKeyWithArgs({
-  abi: abi6,
-  method: method9,
-  address: getConfig(network).xAllocationVotingContractAddress,
-  args: [BigInt(roundId || 0)]
-});
-var useAllocationsRoundState = (roundId) => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi6,
-    address: getConfig(network.type).xAllocationVotingContractAddress,
-    method: method9,
-    args: [BigInt(roundId || 0)],
-    queryOptions: {
-      enabled: !!roundId && !!network.type,
-      select: (data) => data[0]
-    }
-  });
-};
-
-// src/hooks/thor/contracts/XAllocationVoting/useCurrentAllocationsRoundId.ts
-var abi7 = XAllocationVoting__factory.abi;
-var method10 = "currentRoundId";
-var getCurrentAllocationsRoundIdQueryKey = (network) => getCallClauseQueryKeyWithArgs({
-  abi: abi7,
-  method: method10,
-  address: getConfig(network).xAllocationVotingContractAddress,
-  args: []
-});
-var useCurrentAllocationsRoundId = () => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi7,
-    address: getConfig(network.type).xAllocationVotingContractAddress,
-    method: method10,
-    args: [],
-    queryOptions: {
-      enabled: !!network.type,
-      select: (data) => data[0].toString()
-    }
-  });
-};
-
-// src/hooks/thor/contracts/XAllocationVoting/useHasVotedInRound.ts
-var method11 = "hasVoted";
-var abi8 = XAllocationVoting__factory.abi;
-var getHasVotedInRoundQueryKey = (roundId, address, networkType) => getCallClauseQueryKeyWithArgs({
-  abi: abi8,
-  address: getConfig(networkType).xAllocationVotingContractAddress,
-  method: method11,
-  args: [BigInt(roundId || 0), address]
-});
-var useHasVotedInRound = (roundId, address) => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi8,
-    address: getConfig(network.type).xAllocationVotingContractAddress,
-    method: method11,
-    args: [BigInt(roundId || 0), address],
-    queryOptions: {
-      enabled: !!roundId && !!address,
-      select: (data) => data[0]
-    }
-  });
-};
-var getAllocationsRoundsEvents = async (thor, networkType) => {
-  const xAllocationVotingContract = getConfig(networkType).xAllocationVotingContractAddress;
-  const eventAbi = thor.contracts.load(xAllocationVotingContract, XAllocationVoting__factory.abi).getEventAbi("RoundCreated");
-  const events = await getAllEventLogs({
-    thor,
-    filterCriteria: [
-      {
-        criteria: {
-          address: xAllocationVotingContract,
-          topic0: eventAbi.signatureHash
-        },
-        eventAbi
-      }
-    ],
-    nodeUrl: getConfig(networkType).nodeUrl
-  });
-  const decodedCreatedAllocationEvents = [];
-  events.forEach((event) => {
-    if (!event.decodedData) {
-      throw new Error("Event data not decoded");
-    }
-    if (!compareAddresses(event.address, xAllocationVotingContract)) {
-      throw new Error("Event address not valid");
-    }
-    const [roundId, proposer, voteStart, voteEnd, appsIds] = event.decodedData;
-    decodedCreatedAllocationEvents.push({
-      roundId: roundId.toString(),
-      proposer,
-      voteStart: voteStart.toString(),
-      voteEnd: voteEnd.toString(),
-      appsIds: appsIds.map((appId) => appId.toString())
-    });
-  });
-  return {
-    created: decodedCreatedAllocationEvents
-  };
-};
-var getAllocationsRoundsEventsQueryKey = () => [
-  "VECHAIN_KIT",
-  "allocationRoundsEvents"
-];
-var useAllocationsRoundsEvents = () => {
-  const thor = useThor();
-  const { network } = useVeChainKitConfig();
-  return useQuery({
-    queryKey: getAllocationsRoundsEventsQueryKey(),
-    queryFn: async () => await getAllocationsRoundsEvents(thor, network.type),
-    enabled: !!thor && !!network.type
-  });
-};
-
-// src/hooks/thor/contracts/XAllocationVoting/custom/useCurrentAllocationsRound.ts
-var useCurrentAllocationsRound = () => {
-  const currentRoundId = useCurrentAllocationsRoundId();
-  const allocationsRound = useAllocationsRound(currentRoundId.data);
-  return {
-    ...allocationsRound,
-    isLoading: currentRoundId.isLoading || allocationsRound.isLoading,
-    isError: currentRoundId.isError || allocationsRound.isError,
-    error: currentRoundId.error || allocationsRound.error
-  };
-};
-var useAllocationsRound = (roundId) => {
-  const { data: currentBlock } = useCurrentBlock();
-  const currentAllocationId = useCurrentAllocationsRoundId();
-  const currentAllocationState = useAllocationsRoundState(roundId);
-  const allocationRoundsEvents = useAllocationsRoundsEvents();
-  const { network } = useVeChainKitConfig();
-  const currentAllocationRound = useMemo(() => {
-    if (!currentAllocationId.data || !allocationRoundsEvents.data)
-      return;
-    const roundInfo = allocationRoundsEvents.data.created.find(
-      (allocationRound) => allocationRound.roundId === roundId
-    );
-    if (!roundInfo) return;
-    return {
-      ...roundInfo,
-      state: currentAllocationState.data,
-      isCurrent: roundId === currentAllocationId.data
-    };
-  }, [
-    currentAllocationId,
-    allocationRoundsEvents,
-    currentAllocationState,
-    roundId
-  ]);
-  const isLoading = currentAllocationId.isLoading || allocationRoundsEvents.isLoading || currentAllocationState.isLoading;
-  const isError = currentAllocationId.isError || allocationRoundsEvents.isError || currentAllocationState.isError;
-  const error = currentAllocationId.error || allocationRoundsEvents.error || currentAllocationState.error;
-  const blockTime = getConfig(network.type).network.blockTime;
-  const estimatedEndTime = useMemo(() => {
-    if (!currentAllocationRound) return null;
-    const endBlock = Number(currentAllocationRound.voteEnd);
-    if (!endBlock || !currentBlock) return null;
-    const endBlockFromNow = endBlock - currentBlock.number;
-    const durationLeftTimestamp = endBlockFromNow * blockTime;
-    return Date.now() + durationLeftTimestamp;
-  }, [currentBlock, currentAllocationRound, blockTime]);
-  const estimatedStartTime = useMemo(() => {
-    if (!currentAllocationRound) return null;
-    const startBlock = Number(currentAllocationRound.voteStart);
-    if (!startBlock || !currentBlock) return null;
-    const endBlockFromNow = startBlock - currentBlock.number;
-    const durationLeftTimestamp = endBlockFromNow * blockTime;
-    return Date.now() + durationLeftTimestamp;
-  }, [currentBlock, currentAllocationRound, blockTime]);
-  const isFirstRound = currentAllocationRound?.roundId === "1";
-  const isLastRound = currentAllocationRound?.roundId === allocationRoundsEvents?.data?.created.length.toString();
-  return {
-    ...allocationRoundsEvents,
-    data: {
-      ...currentAllocationRound,
-      voteStartTimestamp: estimatedStartTime,
-      voteEndTimestamp: estimatedEndTime,
-      isFirstRound,
-      isLastRound
-    },
-    isLoading,
-    isError,
-    error
-  };
-};
-var contractAbi5 = XAllocationVotingGovernor__factory.abi;
-var method12 = "getAppVotes";
-var getXAppVotesQueryKey = (networkType, roundId, appId) => getCallClauseQueryKeyWithArgs({
-  abi: contractAbi5,
-  address: getConfig(networkType).xAllocationVotingContractAddress,
-  method: method12,
-  args: [BigInt(roundId || 0), appId]
-});
-var useXAppVotes = (roundId, appId) => {
-  const { network } = useVeChainKitConfig();
-  const contractAddress = getConfig(
-    network.type
-  ).xAllocationVotingContractAddress;
-  return useCallClause({
-    address: contractAddress,
-    abi: contractAbi5,
-    method: method12,
-    args: [BigInt(roundId || 0), appId],
-    queryOptions: {
-      enabled: !!roundId && !!appId && !!network.type,
-      select: (res) => formatEther(BigInt(res[0]))
-    }
-  });
-};
-
-// src/hooks/thor/logs/logUtils.ts
-var MAX_EVENTS_PER_QUERY = 1e3;
-var getEventLogs = async ({
-  thor,
-  order = "asc",
-  offset = 0,
-  limit = MAX_EVENTS_PER_QUERY,
-  from = 0,
-  to = thor.blocks.getHeadBlock()?.number,
-  filterCriteria
-}) => {
-  const response = await thor.logs.filterEventLogs({
-    range: {
-      from,
-      to,
-      unit: "block"
-    },
-    options: {
-      offset,
-      limit
-    },
-    order,
-    criteriaSet: filterCriteria
-  });
-  if (!response) throw new Error("Failed to fetch events");
-  return response;
-};
-var getAllEventLogs = async ({
-  nodeUrl,
-  thor,
-  order = "asc",
-  from = 0,
-  to,
-  filterCriteria
-}) => {
-  const allEvents = [];
-  let offset = 0;
-  while (true) {
-    const events = await getEventLogs({
-      thor,
-      filterCriteria,
-      from,
-      to: to ?? Number.MAX_SAFE_INTEGER,
-      limit: MAX_EVENTS_PER_QUERY,
-      order,
-      offset
-    });
-    allEvents.push(...events);
-    if (events.length < MAX_EVENTS_PER_QUERY) {
-      return allEvents;
-    }
-    offset += MAX_EVENTS_PER_QUERY;
-  }
-};
-
-// src/hooks/thor/transactions/transactionUtils.ts
-var estimateTxGas = async (thor, clauses, caller) => {
-  const response = await thor.transactions.estimateGas(clauses, caller);
-  if (response.reverted) throw new Error("Failed to estimate gas");
-  return response.totalGas;
-};
-var useSendTransaction = ({
-  signerAccountAddress,
-  clauses,
-  onTxConfirmed,
-  onTxFailedOrCancelled,
-  suggestedMaxGas,
-  privyUIOptions
-}) => {
+var useSendTransaction = ({
+  signerAccountAddress,
+  clauses,
+  onTxConfirmed,
+  onTxFailedOrCancelled,
+  suggestedMaxGas,
+  privyUIOptions
+}) => {
   const thor = useThor();
   const { signer } = useWallet$1();
   const { connection } = useWallet();
@@ -19209,16 +18267,14 @@ var AddressDisplayCard = ({
 }) => {
   const { darkMode: isDark } = useVeChainKitConfig();
   const { t } = useTranslation();
-  const { isLoading: totalBalanceLoading } = useTotalBalance({
-    address
-  });
-  const { tokens: tokens2, isLoading: tokensLoading } = useTokensWithValues({
+  const { isLoading: totalBalanceLoading } = useTotalBalance({ address });
+  const { tokens, isLoading: tokensLoading } = useTokensWithValues({
     address
   });
   const tokenData = useMemo(() => {
     if (!tokenAddress) return null;
-    return tokens2.find((token) => token.address === tokenAddress);
-  }, [tokens2, tokenAddress]);
+    return tokens.find((token) => token.address === tokenAddress);
+  }, [tokens, tokenAddress]);
   const displayBalance = useMemo(() => {
     if (balance !== void 0) return balance;
     if (tokenData) {
@@ -20488,7 +19544,7 @@ var useVeChainKitConfig = () => {
 var validateConfig = (props) => {
   const errors = [];
   const requiresFeeDelegation = props.privy !== void 0 || props.loginMethods?.some(
-    (method13) => method13.method === "vechain" || method13.method === "ecosystem"
+    (method7) => method7.method === "vechain" || method7.method === "ecosystem"
   );
   if (requiresFeeDelegation) {
     if (!props.feeDelegation) {
@@ -20516,7 +19572,7 @@ var validateConfig = (props) => {
   if (props.loginMethods) {
     if (!props.privy) {
       const invalidMethods = props.loginMethods.filter(
-        (method13) => ["email", "google", "passkey", "more"].includes(method13.method)
+        (method7) => ["email", "google", "passkey", "more"].includes(method7.method)
       );
       if (invalidMethods.length > 0) {
         errors.push(
@@ -20581,7 +19637,7 @@ var VeChainKitProvider = (props) => {
   const validatedLoginMethods = loginMethods;
   const allowedEcosystemApps = useMemo(() => {
     const userEcosystemMethods = validatedLoginMethods?.find(
-      (method13) => method13.method === "ecosystem"
+      (method7) => method7.method === "ecosystem"
     );
     return userEcosystemMethods?.allowedApps ?? DEFAULT_PRIVY_ECOSYSTEM_APPS.map((app) => app.id);
   }, [validatedLoginMethods]);
@@ -21115,6 +20171,6 @@ var VechainKitThemeProvider = ({
   ] });
 };
 
-export { AccessAndSecurityContent, AccessAndSecurityModalProvider, AccountAvatar, AccountCustomizationModalProvider, AccountDetailsButton, AccountMainContent, AccountModal, AccountModalProvider, AccountSelector, ActionButton, AddressDisplay, AddressDisplayCard, AppearanceSettingsContent, AssetButton, AssetsContent, BalanceSection, BaseModal, BridgeContent, ChangeCurrencyContent, ChooseNameContent, ChooseNameModalProvider, ChooseNameSearchContent, ChooseNameSummaryContent, ConnectModal, ConnectModalProvider, ConnectPopover, ConnectionButton, CrossAppConnectionSecurityCard, CustomizationContent, CustomizationSummaryContent, DappKitButton, DisconnectConfirmContent, DomainRequiredAlert, EcosystemButton, EcosystemModal, EmailLoginButton, EmbeddedWalletContent, ExchangeWarningAlert, ExploreEcosystemModalProvider, FAQContent, FAQModalProvider, FadeInView, FadeInViewFromBottom, FadeInViewFromLeft, FadeInViewFromRight, FeatureAnnouncementCard, GeneralSettingsContent, LanguageSettingsContent, LegalDocumentItem, LegalDocumentsModal, LegalDocumentsProvider, LocalStorageKey, LoginLoadingModal, LoginWithGoogleButton, MAX_IMAGE_SIZE, MainContent, ManageCustomTokenContent, ModalBackButton, ModalFAQButton, ModalNotificationButton, NotificationsModalProvider, PRICE_FEED_IDS, PasskeyLoginButton, PrivyButton, PrivyWalletProvider, ProfileCard, ProfileContent, ProfileModalProvider, QuickActionsSection, ReceiveModalProvider, ReceiveTokenContent, RoundState, ScrollToTopWrapper, SelectTokenContent, SendTokenContent, SendTokenModalProvider, SendTokenSummaryContent, SettingsContent, ShareButtons, SocialIcons, StickyFooterContainer, StickyHeaderContainer, SwapTokenContent, TermsAndPrivacyContent, TransactionButtonAndStatus, TransactionModal, TransactionModalContent, TransactionModalProvider, TransactionToast, TransactionToastProvider, UpgradeSmartAccountContent, UpgradeSmartAccountModal, UpgradeSmartAccountModalProvider, VeChainKitContext, VeChainKitProvider, VeChainLoginButton, VeChainWithPrivyLoginButton, VechainKitThemeProvider, VersionFooter, WalletButton, WalletModalProvider, compressImages, currentBlockQueryKey, fetchAppHubApps, fetchPrivyAppInfo, fetchPrivyStatus, fetchVechainDomain, getAccountAddress, getAccountAddressQueryKey, getAccountBalance, getAccountBalanceQueryKey, getAccountImplementationAddress, getAccountImplementationAddressQueryKey, getAccountVersionQueryKey, getAllEventLogs, getAllocationsRoundStateQueryKey, getAllocationsRoundsEvents, getAllocationsRoundsEventsQueryKey, getAppHubAppsQueryKey, getAvatar, getAvatarLegacy, getAvatarLegacyQueryKey, getAvatarOfAddressQueryKey, getAvatarQueryKey, getB3trBalance, getB3trBalanceQueryKey, getCallClauseQueryKey, getCallClauseQueryKeyWithArgs, getChainId, getChainIdQueryKey, getCurrentAccountImplementationVersion, getCurrentAccountImplementationVersionQueryKey, getCurrentAllocationsRoundIdQueryKey, getCustomTokenBalance, getCustomTokenBalanceQueryKey, getCustomTokenInfo, getDomainsOfAddress, getDomainsOfAddressQueryKey, getEnsRecordExistsQueryKey, getErc20Balance, getErc20BalanceQueryKey, getEventLogs, getHasV1SmartAccount, getHasV1SmartAccountQueryKey, getHasVotedInRoundQueryKey, getIpfsImage, getIpfsImageQueryKey, getIpfsMetadata, getIpfsMetadataQueryKey, getIsDeployed, getIsDeployedQueryKey, getIsDomainProtectedQueryKey, getIsPersonAtTimepointQueryKey, getIsPersonQueryKey, getPrivyAppInfoQueryKey, getResolverAddressQueryKey, getRoundRewardQueryKey, getRoundXApps, getRoundXAppsQueryKey, getSmartAccount, getSmartAccountQueryKey, getTextRecords, getTextRecordsQueryKey, getTokenInfo, getTokenUsdPrice, getTokenUsdPriceQueryKey, getTokensInfoByOwnerQueryKey, getUpgradeRequired, getUpgradeRequiredForAccount, getUpgradeRequiredForAccountQueryKey, getUpgradeRequiredQueryKey, getUserBotSignalsQueryKey, getUserNodesQueryKey, getUserVotesInRound, getUserVotesInRoundQueryKey, getVeDelegateBalance, getVeDelegateBalanceQueryKey, getVechainDomainQueryKey, getVersion, getVersionQueryKey, getVot3Balance, getVot3BalanceQueryKey, getVotesInRoundQueryKey, getXAppMetadata, getXAppMetadataQueryKey, getXAppRoundEarnings, getXAppRoundEarningsQueryKey, getXAppTotalEarningsQueryKey, getXAppVotesQueryKey, getXApps, getXAppsMetadataBaseUriQueryKey, getXAppsQueryKey, getXAppsSharesQueryKey, imageCompressionOptions, txReceiptQueryKey, useAccessAndSecurityModal, useAccountBalance, useAccountCustomizationModal, useAccountImplementationAddress, useAccountModal, useAllocationsRound, useAllocationsRoundState, useAllocationsRoundsEvents, useAppHubApps, useBuildTransaction, useCallClause, useChooseNameModal, useClaimVeWorldSubdomain, useClaimVetDomain, useConnectModal, useCrossAppConnectionCache, useCurrency, useCurrentAccountImplementationVersion, useCurrentAllocationsRound, useCurrentAllocationsRoundId, useCurrentBlock, useCustomTokens, useEcosystemShortcuts, useEnsRecordExists, useExploreEcosystemModal, useFAQModal, useFeatureAnnouncement, useFetchAppInfo, useFetchPrivyStatus, useGalaxyMemberTokensInfo, useGetAccountAddress, useGetAccountVersion, useGetAvatar, useGetAvatarLegacy, useGetAvatarOfAddress, useGetB3trBalance, useGetChainId, useGetCustomTokenBalances, useGetCustomTokenInfo, useGetDomainsOfAddress, useGetErc20Balance, useGetNodeUrl, useGetResolverAddress, useGetTextRecords, useGetTokenUsdPrice, useGetUserNode, useGetUserNodes, useGetVeDelegateBalance, useGetVot3Balance, useHasV1SmartAccount, useHasVotedInRound, useIpfsImage, useIpfsImageList, useIpfsMetadata, useIpfsMetadatas, useIsDomainProtected, useIsPWA, useIsPerson, useIsPersonAtTimepoint, useIsSmartAccountDeployed, useIsUserPerson, useLegalDocuments, useLocalStorage, useLoginModalContent, useLoginWithOAuth2 as useLoginWithOAuth, useLoginWithPasskey, useLoginWithVeChain, useMostVotedAppsInRound, useMultipleXAppRoundEarnings, useNotificationAlerts, useNotifications, useNotificationsModal, usePrivyWalletProvider, useProfileModal, useReceiveModal, useRefreshBalances, useRefreshFactoryQueries, useRefreshMetadata, useRefreshSmartAccountQueries, useRoundReward, useRoundXApps, useScrollToTop, useSendTokenModal, useSendTransaction, useSignMessage2 as useSignMessage, useSignTypedData2 as useSignTypedData, useSingleImageUpload, useSmartAccount, useSmartAccountVersion, useSyncableLocalStorage, useTokenBalances, useTokenBalances2, useTokenPrices, useTokenPrices2, useTokensWithValues, useTotalBalance, useTransactionModal, useTransactionToast, useTransferERC20, useTransferVET, useTxReceipt, useUnsetDomain, useUpdateTextRecord, useUpgradeRequired, useUpgradeRequiredForAccount, useUpgradeSmartAccount, useUpgradeSmartAccountModal, useUploadImages, useUserBotSignals, useUserVotesInRound, useVeChainKitConfig, useVechainDomain, useVotesInRound, useVotingRewards, useWallet, useWalletMetadata, useWalletModal2 as useWalletModal, useXApp, useXAppMetadata, useXAppRoundEarnings, useXAppTotalEarnings, useXAppVotes, useXApps, useXAppsMetadataBaseUri, useXAppsShares };
+export { AccessAndSecurityContent, AccessAndSecurityModalProvider, AccountAvatar, AccountCustomizationModalProvider, AccountDetailsButton, AccountMainContent, AccountModal, AccountModalProvider, AccountSelector, ActionButton, AddressDisplay, AddressDisplayCard, AppearanceSettingsContent, AssetButton, AssetsContent, BalanceSection, BaseModal, BridgeContent, ChangeCurrencyContent, ChooseNameContent, ChooseNameModalProvider, ChooseNameSearchContent, ChooseNameSummaryContent, ConnectModal, ConnectModalProvider, ConnectPopover, ConnectionButton, CrossAppConnectionSecurityCard, CustomizationContent, CustomizationSummaryContent, DappKitButton, DisconnectConfirmContent, DomainRequiredAlert, EcosystemButton, EcosystemModal, EmailLoginButton, EmbeddedWalletContent, ExchangeWarningAlert, ExploreEcosystemModalProvider, FAQContent, FAQModalProvider, FadeInView, FadeInViewFromBottom, FadeInViewFromLeft, FadeInViewFromRight, FeatureAnnouncementCard, GeneralSettingsContent, LanguageSettingsContent, LegalDocumentItem, LegalDocumentsModal, LegalDocumentsProvider, LocalStorageKey, LoginLoadingModal, LoginWithGoogleButton, MAX_IMAGE_SIZE, MainContent, ManageCustomTokenContent, ModalBackButton, ModalFAQButton, ModalNotificationButton, NotificationsModalProvider, PRICE_FEED_IDS, PasskeyLoginButton, PrivyButton, PrivyWalletProvider, ProfileCard, ProfileContent, ProfileModalProvider, QuickActionsSection, ReceiveModalProvider, ReceiveTokenContent, ScrollToTopWrapper, SelectTokenContent, SendTokenContent, SendTokenModalProvider, SendTokenSummaryContent, SettingsContent, ShareButtons, SocialIcons, StickyFooterContainer, StickyHeaderContainer, SwapTokenContent, TermsAndPrivacyContent, TransactionButtonAndStatus, TransactionModal, TransactionModalContent, TransactionModalProvider, TransactionToast, TransactionToastProvider, UpgradeSmartAccountContent, UpgradeSmartAccountModal, UpgradeSmartAccountModalProvider, VeChainKitContext, VeChainKitProvider, VeChainLoginButton, VeChainWithPrivyLoginButton, VechainKitThemeProvider, VersionFooter, WalletButton, WalletModalProvider, compressImages, currentBlockQueryKey, fetchAppHubApps, fetchPrivyAppInfo, fetchPrivyStatus, fetchVechainDomain, getAccountAddress, getAccountAddressQueryKey, getAccountBalance, getAccountBalanceQueryKey, getAccountImplementationAddress, getAccountImplementationAddressQueryKey, getAccountVersionQueryKey, getAllEventLogs, getAppHubAppsQueryKey, getAvatar, getAvatarLegacy, getAvatarLegacyQueryKey, getAvatarOfAddressQueryKey, getAvatarQueryKey, getB3trBalance, getB3trBalanceQueryKey, getCallClauseQueryKey, getCallClauseQueryKeyWithArgs, getChainId, getChainIdQueryKey, getCurrentAccountImplementationVersion, getCurrentAccountImplementationVersionQueryKey, getCurrentAllocationsRoundIdQueryKey, getCustomTokenBalance, getCustomTokenBalanceQueryKey, getCustomTokenInfo, getDomainsOfAddress, getDomainsOfAddressQueryKey, getEnsRecordExistsQueryKey, getErc20Balance, getErc20BalanceQueryKey, getEventLogs, getHasV1SmartAccount, getHasV1SmartAccountQueryKey, getIpfsImage, getIpfsImageQueryKey, getIpfsMetadata, getIpfsMetadataQueryKey, getIsDeployed, getIsDeployedQueryKey, getIsDomainProtectedQueryKey, getIsPersonQueryKey, getPrivyAppInfoQueryKey, getResolverAddressQueryKey, getRoundXAppsQueryKey, getSmartAccount, getSmartAccountQueryKey, getTextRecords, getTextRecordsQueryKey, getTokenInfo, getTokenUsdPrice, getTokenUsdPriceQueryKey, getUpgradeRequired, getUpgradeRequiredForAccount, getUpgradeRequiredForAccountQueryKey, getUpgradeRequiredQueryKey, getVechainDomainQueryKey, getVersion, getVersionQueryKey, getVot3Balance, getVot3BalanceQueryKey, getXAppMetadata, getXAppsSharesQueryKey, imageCompressionOptions, txReceiptQueryKey, useAccessAndSecurityModal, useAccountBalance, useAccountCustomizationModal, useAccountImplementationAddress, useAccountModal, useAppHubApps, useBuildTransaction, useCallClause, useChooseNameModal, useClaimVeWorldSubdomain, useClaimVetDomain, useConnectModal, useCrossAppConnectionCache, useCurrency, useCurrentAccountImplementationVersion, useCurrentAllocationsRoundId, useCurrentBlock, useCustomTokens, useEcosystemShortcuts, useEnsRecordExists, useExploreEcosystemModal, useFAQModal, useFeatureAnnouncement, useFetchAppInfo, useFetchPrivyStatus, useGetAccountAddress, useGetAccountVersion, useGetAvatar, useGetAvatarLegacy, useGetAvatarOfAddress, useGetB3trBalance, useGetChainId, useGetCustomTokenBalances, useGetCustomTokenInfo, useGetDomainsOfAddress, useGetErc20Balance, useGetNodeUrl, useGetResolverAddress, useGetTextRecords, useGetTokenUsdPrice, useGetVot3Balance, useHasV1SmartAccount, useIpfsImage, useIpfsImageList, useIpfsMetadata, useIpfsMetadatas, useIsDomainProtected, useIsPWA, useIsPerson, useIsSmartAccountDeployed, useLegalDocuments, useLocalStorage, useLoginModalContent, useLoginWithOAuth2 as useLoginWithOAuth, useLoginWithPasskey, useLoginWithVeChain, useMostVotedAppsInRound, useNotificationAlerts, useNotifications, useNotificationsModal, usePrivyWalletProvider, useProfileModal, useReceiveModal, useRefreshBalances, useRefreshFactoryQueries, useRefreshMetadata, useRefreshSmartAccountQueries, useRoundXApps, useScrollToTop, useSendTokenModal, useSendTransaction, useSignMessage2 as useSignMessage, useSignTypedData2 as useSignTypedData, useSingleImageUpload, useSmartAccount, useSmartAccountVersion, useSyncableLocalStorage, useTokenBalances, useTokenPrices, useTokensWithValues, useTotalBalance, useTransactionModal, useTransactionToast, useTransferERC20, useTransferVET, useTxReceipt, useUnsetDomain, useUpdateTextRecord, useUpgradeRequired, useUpgradeRequiredForAccount, useUpgradeSmartAccount, useUpgradeSmartAccountModal, useUploadImages, useVeChainKitConfig, useVechainDomain, useWallet, useWalletMetadata, useWalletModal2 as useWalletModal, useXAppMetadata, useXAppsShares };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map