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

package/dist/index.cjs

@@ -23,10 +23,11 @@ var ethers = require('ethers');
 var sdkCore = require('@vechain/sdk-core');
 var viem = require('viem');
 var zod = require('zod');
+var bignumber_js = require('bignumber.js');
 var wagmi = require('wagmi');
 var rainbowKit = require('@privy-io/cross-app-connect/rainbow-kit');
 var reactDeviceDetect = require('react-device-detect');
-var BigNumber = require('bignumber.js');
+var axios = require('axios');
 var imageCompression = require('browser-image-compression');
 var lu = require('react-icons/lu');
 var md = require('react-icons/md');
@@ -58,7 +59,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var i18n__default = /*#__PURE__*/_interopDefault(i18n);
 var React10__default = /*#__PURE__*/_interopDefault(React10);
 var VeChainKitMixpanel__default = /*#__PURE__*/_interopDefault(VeChainKitMixpanel);
-var BigNumber__default = /*#__PURE__*/_interopDefault(BigNumber);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
 var imageCompression__default = /*#__PURE__*/_interopDefault(imageCompression);
 var createCache__default = /*#__PURE__*/_interopDefault(createCache);
 
@@ -4361,15 +4362,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: ({
@@ -4824,7 +4825,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__ */ jsxRuntime.jsxs(
@@ -6127,13 +6128,13 @@ var useUnsetDomain = ({
     }
   };
 };
-var useTokenBalances = ({ address = "" }) => {
+var useTokenBalances = (address) => {
   const { network } = useVeChainKitConfig();
   const config = chunkLMX37RCG_cjs.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);
@@ -6206,6 +6207,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(
+    chunkLMX37RCG_cjs.getConfig(network).oracleContractAddress,
+    chunk5GZ7N47F_cjs.IVechainEnergyOracleV1__factory.abi
+  ).read.getLatestValue(PRICE_FEED_IDS[token]);
+  if (!res) throw new Error(`Failed to get price of ${token}`);
+  return new bignumber_js.BigNumber(res[0].toString()).div(1e12).toNumber();
+};
+var getTokenUsdPriceQueryKey = (token) => [
+  "VECHAIN_KIT_PRICE",
+  token
+];
+var useGetTokenUsdPrice = (token) => {
+  const thor = dappKitReact.useThor();
+  const { network } = useVeChainKitConfig();
+  return reactQuery.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 = chunkLMX37RCG_cjs.getConfig(network.type);
@@ -6295,9 +6326,7 @@ var useCurrency = () => {
 var useTokensWithValues = ({
   address = ""
 }) => {
-  const { balances, isLoading: balancesLoading } = useTokenBalances({
-    address
-  });
+  const { balances, isLoading: balancesLoading } = useTokenBalances(address);
   const {
     prices,
     exchangeRates,
@@ -6366,6 +6395,60 @@ var useTotalBalance = ({ address = "" }) => {
     hasAnyBalance: tokensWithBalance.length > 0
   };
 };
+
+// src/hooks/api/wallet/useCurrentAllocationsRoundId.ts
+var abi = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
+var method = "currentRoundId";
+var getCurrentAllocationsRoundIdQueryKey = (address) => getCallClauseQueryKey({ abi, address, method });
+var useCurrentAllocationsRoundId = () => {
+  const { network } = useVeChainKitConfig();
+  const address = chunkLMX37RCG_cjs.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, chunk5GZ7N47F_cjs.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 = dappKitReact.useThor();
+  const { network } = useVeChainKitConfig();
+  return reactQuery.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 */,
@@ -6412,6 +6495,223 @@ var useCustomTokens = () => {
     isDefaultToken
   };
 };
+var getB3trBalance = async (thor, network, address) => {
+  const res = await thor.contracts.load(chunkLMX37RCG_cjs.getConfig(network).b3trContractAddress, chunk5GZ7N47F_cjs.B3TR__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error("Failed to get b3tr balance");
+  const original = res[0].toString();
+  const scaled = ethers.formatEther(original);
+  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getB3trBalanceQueryKey = (address) => [
+  "VEBETTERDAO_BALANCE",
+  address,
+  "B3TR"
+];
+var useGetB3trBalance = (address) => {
+  const thor = dappKitReact.useThor();
+  const { network } = useVeChainKitConfig();
+  return reactQuery.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, chunk5GZ7N47F_cjs.ERC20__factory.abi).read.balanceOf([address]);
+  if (!res) throw new Error(`Failed to get balance of ${token.address}`);
+  const original = res[0];
+  const scaled = viem.formatEther(BigInt(original));
+  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
+  const { customTokens } = useCustomTokens();
+  return reactQuery.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, chunk5GZ7N47F_cjs.IERC20__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error(`Failed to get balance of ${tokenAddress}`);
+  const original = res[0].toString();
+  const scaled = ethers.formatEther(original);
+  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getErc20BalanceQueryKey = (tokenAddress, address) => ["VECHAIN_KIT", "BALANCE", "ERC20", tokenAddress, address];
+var useGetErc20Balance = (tokenAddress, address) => {
+  const thor = dappKitReact.useThor();
+  return reactQuery.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(chunkLMX37RCG_cjs.getConfig(network).vot3ContractAddress, chunk5GZ7N47F_cjs.IVOT3__factory.abi).read.balanceOf(address);
+  if (!res) throw new Error("Reverted");
+  const original = res[0].toString();
+  const scaled = ethers.formatEther(original);
+  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
+  return {
+    original,
+    scaled,
+    formatted
+  };
+};
+var getVot3BalanceQueryKey = (address) => [
+  "VEBETTERDAO_BALANCE",
+  address,
+  "VOT3"
+];
+var useGetVot3Balance = (address) => {
+  const thor = dappKitReact.useThor();
+  const { network } = useVeChainKitConfig();
+  return reactQuery.useQuery({
+    queryKey: getVot3BalanceQueryKey(address),
+    queryFn: async () => getVot3Balance(thor, network.type, address),
+    enabled: !!thor && !!address && !!network.type
+  });
+};
+
+// src/hooks/api/wallet/useIsPerson.ts
+var abi2 = chunk5GZ7N47F_cjs.VeBetterPassport__factory.abi;
+var method2 = "isPerson";
+var getIsPersonQueryKey = (user, network) => {
+  const address = chunkLMX37RCG_cjs.getConfig(network).veBetterPassportContractAddress;
+  return getCallClauseQueryKeyWithArgs({
+    abi: abi2,
+    address,
+    method: method2,
+    args: [user]
+  });
+};
+var useIsPerson = (user) => {
+  const { network } = useVeChainKitConfig();
+  const address = chunkLMX37RCG_cjs.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 = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
+var method3 = "getAppsOfRound";
+var getRoundXAppsQueryKey = (roundId, networkType) => getCallClauseQueryKeyWithArgs({
+  abi: abi3,
+  address: chunkLMX37RCG_cjs.getConfig(networkType).xAllocationVotingContractAddress,
+  method: method3,
+  args: [BigInt(roundId ?? 0)]
+});
+var useRoundXApps = (roundId) => {
+  const { network } = useVeChainKitConfig();
+  const address = chunkLMX37RCG_cjs.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 = chunk5GZ7N47F_cjs.XAllocationPool__factory.abi;
+var method4 = "getAppShares";
+var getXAppsSharesQueryKey = (roundId) => [
+  "VECHAIN_KIT",
+  "XApps",
+  "Shares",
+  roundId
+];
+var useXAppsShares = (apps, roundId) => {
+  const thor = dappKitReact.useThor();
+  const { network } = useVeChainKitConfig();
+  const address = chunkLMX37RCG_cjs.getConfig(network.type).xAllocationPoolContractAddress;
+  return reactQuery.useQuery({
+    queryKey: getXAppsSharesQueryKey(roundId),
+    queryFn: async () => {
+      const shares = await chunkLMX37RCG_cjs.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 = React10.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.",
@@ -6744,170 +7044,30 @@ var useRefreshBalances = () => {
   };
   return { refresh };
 };
-var getCustomTokenBalances = async (thor, address, customTokens) => {
-  const clauses = customTokens.map((token) => {
-    const erc20Contract = thor.contracts.load(
-      token.address,
-      chunk5GZ7N47F_cjs.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 = ethers.formatEther(BigInt(original)) || "0";
-    return {
-      address: token.address,
-      symbol: token.symbol,
-      balance: scaled
-    };
-  });
-};
-var getTokenBalances = async (thor, address, network) => {
-  const config = chunkLMX37RCG_cjs.getConfig(network);
-  const [b3trBalance, vot3Balance, veDelegateBalance, gloDollarBalance] = await chunkLMX37RCG_cjs.executeMultipleClausesCall({
-    thor,
-    calls: [
-      {
-        abi: chunk5GZ7N47F_cjs.IB3TR__factory.abi,
-        address: config.b3trContractAddress,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: chunk5GZ7N47F_cjs.IVOT3__factory.abi,
-        address: config.vot3ContractAddress,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: chunk5GZ7N47F_cjs.IERC20__factory.abi,
-        address: config.veDelegate,
-        functionName: "balanceOf",
-        args: [address]
-      },
-      {
-        abi: chunk5GZ7N47F_cjs.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  const { customTokens } = useCustomTokens();
-  return reactQuery.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 = chunkLMX37RCG_cjs.getConfig(network);
-  const oracleContract = thor.contracts.load(
-    config.oracleContractAddress,
-    chunk5GZ7N47F_cjs.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__default.default((r.result.array?.[0] ?? 0).toString()).div(1e12).toNumber()
+var getXAppMetadata = async (uri, networkType) => {
+  const metadata = await axios__default.default.get(
+    chunkLMX37RCG_cjs.convertUriToUrl(uri, networkType) || "",
+    { timeout: 2e4 }
   );
+  return metadata.data;
 };
-var tokens = ["VET", "VTHO", "B3TR", "EUR", "GBP"];
-var useTokenPrices2 = () => {
+var abi5 = chunk5GZ7N47F_cjs.X2EarnApps__factory.abi;
+var useXAppMetadata = (xAppId) => {
   const thor = dappKitReact.useThor();
   const { network } = useVeChainKitConfig();
-  const config = chunkLMX37RCG_cjs.getConfig(network.type);
   return reactQuery.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 = chunkLMX37RCG_cjs.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;
     }
   });
 };
@@ -7626,8 +7786,8 @@ var ConnectionOptionsStack = () => {
     showMoreLogin,
     isOfficialVeChainApp
   } = useLoginModalContent();
-  return /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { spacing: 4, w: "full", align: "center", children: /* @__PURE__ */ jsxRuntime.jsx(react.Grid, { templateColumns: "repeat(4, 1fr)", gap: 2, w: "full", children: loginMethods?.map(({ method: method13, gridColumn }) => {
-    switch (method13) {
+  return /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { spacing: 4, w: "full", align: "center", children: /* @__PURE__ */ jsxRuntime.jsx(react.Grid, { templateColumns: "repeat(4, 1fr)", gap: 2, w: "full", children: loginMethods?.map(({ method: method7, gridColumn }) => {
+    switch (method7) {
       case "email":
         return showEmailLogin && /* @__PURE__ */ jsxRuntime.jsx(EmailLoginButton, {}, "email");
       case "google":
@@ -7734,7 +7894,7 @@ var MainContent = ({ setCurrentContent, onClose }) => {
     }
   }, [connection.isConnected, onClose]);
   const showEcosystemButton = loginMethods?.some(
-    ({ method: method13 }) => method13 === "ecosystem"
+    ({ method: method7 }) => method7 === "ecosystem"
   );
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs(StickyHeaderContainer, { children: [
@@ -13022,13 +13182,13 @@ var PrivyLinkedAccounts = ({ onBack }) => {
   } = reactAuth.usePrivy();
   const canLinkWallets = React10.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;
@@ -14172,17 +14332,7 @@ var ExploreEcosystemContent = ({
   ) : [];
   const filteredDefaultApps = DEFAULT_APPS.filter(
     (dapp) => dapp.name.toLowerCase().includes(searchQuery.toLowerCase())
-  ).map((dapp) => {
-    if (dapp.logoComponent) {
-      return {
-        ...dapp,
-        logoComponent: React10__default.default.cloneElement(dapp.logoComponent, {
-          isDark
-        })
-      };
-    }
-    return dapp;
-  });
+  );
   const filteredAppHubApps = appHubApps?.filter(
     (app) => (
       // Text search filter
@@ -14269,10 +14419,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__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: filteredVbdApps.map((dapp) => /* @__PURE__ */ jsxRuntime.jsx(react.GridItem, { children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -15021,7 +15168,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__ */ jsxRuntime.jsx(
@@ -16564,14 +16711,14 @@ var ReceiveModalProvider = ({ children }) => /* @__PURE__ */ jsxRuntime.jsx(jsxR
 var useLoginModalContent = () => {
   const { privy, loginMethods } = useVeChainKitConfig();
   const isVeChainApp = privy?.appId === chunkLMX37RCG_cjs.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 = React10.useMemo(() => {
     if (!loginMethods) return true;
@@ -16995,24 +17142,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
 }) => {
@@ -17021,14 +17168,14 @@ var useCallClause = ({
     queryKey: getCallClauseQueryKeyWithArgs({
       abi: abi9,
       address,
-      method: method13,
+      method: method7,
       args
     }),
     queryFn: async () => chunkLMX37RCG_cjs.executeCallClause({
       thor,
       contractAddress: address,
       abi: abi9,
-      method: method13,
+      method: method7,
       args
     }),
     ...queryOptions
@@ -17266,9 +17413,9 @@ var useGetAccountAddress = (ownerAddress) => {
 };
 
 // src/hooks/thor/smartAccounts/useGetAccountVersion.ts
-var abi = chunk5GZ7N47F_cjs.SimpleAccountFactory__factory.abi;
+var abi6 = chunk5GZ7N47F_cjs.SimpleAccountFactory__factory.abi;
 var getAccountVersionQueryKey = (accountAddress, ownerAddress, networkType) => getCallClauseQueryKeyWithArgs({
-  abi,
+  abi: abi6,
   address: chunkLMX37RCG_cjs.getConfig(networkType).accountFactoryAddress,
   method: "getAccountVersion",
   args: [accountAddress, ownerAddress]
@@ -17277,7 +17424,7 @@ var useGetAccountVersion = (accountAddress, ownerAddress) => {
   const { network } = useVeChainKitConfig();
   return useCallClause({
     address: chunkLMX37RCG_cjs.getConfig(network.type).accountFactoryAddress,
-    abi,
+    abi: abi6,
     method: "getAccountVersion",
     args: [accountAddress, ownerAddress],
     queryOptions: {
@@ -17290,16 +17437,16 @@ var useGetAccountVersion = (accountAddress, ownerAddress) => {
     }
   });
 };
-var abi2 = chunk5GZ7N47F_cjs.SimpleAccountFactory__factory.abi;
-var method = "hasLegacyAccount";
+var abi7 = chunk5GZ7N47F_cjs.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 chunkLMX37RCG_cjs.executeCallClause({
     thor,
-    abi: abi2,
+    abi: abi7,
     contractAddress: chunkLMX37RCG_cjs.getConfig(networkType).accountFactoryAddress,
-    method,
+    method: method5,
     args: [ownerAddress]
   });
   return hasLegacyAccount;
@@ -17510,15 +17657,15 @@ var useSmartAccount = (ownerAddress) => {
     enabled: !!ownerAddress && !!network.type && !!thor
   });
 };
-var abi3 = chunk5GZ7N47F_cjs.SimpleAccountFactory__factory.abi;
-var method2 = "version";
+var abi8 = chunk5GZ7N47F_cjs.SimpleAccountFactory__factory.abi;
+var method6 = "version";
 var getVersion = async (thor, contractAddress) => {
   if (!contractAddress) throw new Error("Contract address is required");
   const [version] = await chunkLMX37RCG_cjs.executeCallClause({
     thor,
     contractAddress,
-    abi: abi3,
-    method: method2,
+    abi: abi8,
+    method: method6,
     args: []
   });
   return Number(version);
@@ -17706,1165 +17853,76 @@ var useGetChainId = () => {
     refetchInterval: 1e4
   });
 };
-var getB3trBalance = async (thor, network, address) => {
-  const res = await thor.contracts.load(chunkLMX37RCG_cjs.getConfig(network).b3trContractAddress, chunk5GZ7N47F_cjs.B3TR__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error("Failed to get b3tr balance");
-  const original = res[0].toString();
-  const scaled = ethers.formatEther(original);
-  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getB3trBalanceQueryKey = (address) => [
-  "VEBETTERDAO_BALANCE",
-  address,
-  "B3TR"
-];
-var useGetB3trBalance = (address) => {
-  const thor = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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, chunk5GZ7N47F_cjs.ERC20__factory.abi).read.balanceOf([address]);
-  if (!res) throw new Error(`Failed to get balance of ${token.address}`);
-  const original = res[0];
-  const scaled = viem.formatEther(BigInt(original));
-  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  const { customTokens } = useCustomTokens();
-  return reactQuery.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, chunk5GZ7N47F_cjs.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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, chunk5GZ7N47F_cjs.IERC20__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error(`Failed to get balance of ${tokenAddress}`);
-  const original = res[0].toString();
-  const scaled = ethers.formatEther(original);
-  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  return reactQuery.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(
-    chunkLMX37RCG_cjs.getConfig(network).veDelegateTokenContractAddress,
-    chunk5GZ7N47F_cjs.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 = ethers.formatEther(original);
-  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getVeDelegateBalanceQueryKey = (address) => [
-  "VECHAIN_KIT_BALANCE",
-  address,
-  "VE_DELEGATE"
-];
-var useGetVeDelegateBalance = (address) => {
-  const thor = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = chunkLMX37RCG_cjs.getConfig(network.type).galaxyMemberContractAddress;
-  const thor = dappKitReact.useThor();
-  const fetchTokens = async ({ pageParam = 0 }) => {
-    const data = await thor.contracts.load(contractAddress, chunk5GZ7N47F_cjs.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 reactQuery.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 = chunk5GZ7N47F_cjs.NodeManagement__factory.abi;
-var method3 = "getUserNodes";
-var getUserNodesQueryKey = (networkType, user) => getCallClauseQueryKeyWithArgs({
-  abi: contractAbi,
-  address: chunkLMX37RCG_cjs.getConfig(networkType).nodeManagementContractAddress,
-  method: method3,
-  args: [user]
-});
-var useGetUserNodes = (userInput) => {
-  const { network } = useVeChainKitConfig();
-  const contractAddress = chunkLMX37RCG_cjs.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(
-    chunkLMX37RCG_cjs.getConfig(network).oracleContractAddress,
-    chunk5GZ7N47F_cjs.IVechainEnergyOracleV1__factory.abi
-  ).read.getLatestValue(PRICE_FEED_IDS[token]);
-  if (!res) throw new Error(`Failed to get price of ${token}`);
-  return new BigNumber.BigNumber(res[0].toString()).div(1e12).toNumber();
-};
-var getTokenUsdPriceQueryKey = (token) => [
-  "VECHAIN_KIT_PRICE",
-  token
-];
-var useGetTokenUsdPrice = (token) => {
-  const thor = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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(chunkLMX37RCG_cjs.getConfig(network).vot3ContractAddress, chunk5GZ7N47F_cjs.VOT3__factory.abi).read.balanceOf(address);
-  if (!res) throw new Error("Reverted");
-  const original = res[0].toString();
-  const scaled = ethers.formatEther(original);
-  const formatted = scaled === "0" ? "0" : chunkLMX37RCG_cjs.humanNumber(scaled);
-  return {
-    original,
-    scaled,
-    formatted
-  };
-};
-var getVot3BalanceQueryKey = (address) => [
-  "VEBETTERDAO_BALANCE",
-  address,
-  "VOT3"
-];
-var useGetVot3Balance = (address) => {
-  const thor = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.useQuery({
-    queryKey: getVot3BalanceQueryKey(address || ""),
-    queryFn: async () => getVot3Balance(thor, network.type, address),
-    enabled: !!thor && !!address && !!network.type
-  });
-};
-var contractAbi2 = chunk5GZ7N47F_cjs.VeBetterPassport__factory.abi;
-var method4 = "isPerson";
-var getIsPersonQueryKey = (networkType, user) => {
-  const veBetterPassportContractAddress = chunkLMX37RCG_cjs.getConfig(networkType).veBetterPassportContractAddress;
-  return getCallClauseQueryKeyWithArgs({
-    abi: contractAbi2,
-    address: veBetterPassportContractAddress,
-    method: method4,
-    args: [user]
-  });
-};
-var useIsPerson = (user, customEnabled = true) => {
-  const { network } = useVeChainKitConfig();
-  const veBetterPassportContractAddress = chunkLMX37RCG_cjs.getConfig(
-    network.type
-  ).veBetterPassportContractAddress;
-  return useCallClause({
-    abi: contractAbi2,
-    address: veBetterPassportContractAddress,
-    method: method4,
-    args: [user ?? sdkCore.ZERO_ADDRESS],
-    queryOptions: {
-      enabled: !!user && customEnabled && !!veBetterPassportContractAddress && !!network.type,
-      select: (data) => data[0]
-    }
-  });
-};
-var useIsUserPerson = (address) => {
-  return useIsPerson(address);
-};
-var contractAbi3 = chunk5GZ7N47F_cjs.VeBetterPassport__factory.abi;
-var method5 = "isPersonAtTimepoint";
-var getIsPersonAtTimepointQueryKey = (networkType, user, timepoint) => {
-  const veBetterPassportContractAddress = chunkLMX37RCG_cjs.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 = chunkLMX37RCG_cjs.getConfig(
-    network.type
-  ).veBetterPassportContractAddress;
-  return useCallClause({
-    abi: contractAbi3,
-    address: veBetterPassportContractAddress,
-    method: method5,
-    args: [
-      user ?? sdkCore.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 = chunk5GZ7N47F_cjs.VeBetterPassport__factory.abi;
-var method6 = "signaledCounter";
-var getUserBotSignalsQueryKey = (networkType, userAddress) => {
-  return getCallClauseQueryKeyWithArgs({
-    abi: contractAbi4,
-    address: chunkLMX37RCG_cjs.getConfig(networkType).veBetterPassportContractAddress,
-    method: method6,
-    args: [userAddress]
-  });
-};
-var useUserBotSignals = (userAddressInput) => {
-  const { network } = useVeChainKitConfig();
-  const veBetterPassportContractAddress = chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  const queryClient = reactQuery.useQueryClient();
-  const { network } = useVeChainKitConfig();
-  const contractAddress = chunkLMX37RCG_cjs.getConfig(network.type).voterRewardsContractAddress;
-  const rounds = React10.useMemo(() => {
-    return Array.from(
-      { length: parseInt(currentRoundId ?? "0") - 1 },
-      (_, i) => (i + 1).toString()
-    );
-  }, [currentRoundId]);
-  return reactQuery.useQuery({
-    queryKey: getRoundRewardQueryKey("ALL", voter),
-    enabled: !!thor && !!voter && !!currentRoundId && !!rounds.length && !!network.type,
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        contractAddress,
-        chunk5GZ7N47F_cjs.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.BigNumber(0);
-      const roundsRewards = res.map((r, index) => {
-        const roundId = rounds[index];
-        const rewards = r.result.plain;
-        const formattedRewards = viem.formatEther(rewards);
-        total = total.plus(BigNumber.BigNumber(rewards.toString()));
-        queryClient.setQueryData(
-          getRoundRewardQueryKey(roundId, voter),
-          {
-            roundId,
-            rewards: formattedRewards
-          }
-        );
-        return {
-          roundId,
-          rewards,
-          formattedRewards
-        };
-      });
-      const totalFormatted = viem.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: chunkLMX37RCG_cjs.getConfig(network.type).voterRewardsContractAddress,
-    abi: chunk5GZ7N47F_cjs.VoterRewards__factory.abi,
-    method: "getReward",
-    args: [BigInt(roundId || 0), address],
-    queryOptions: {
-      enabled: !!address && !!roundId && !!network.type,
-      select: (data) => ({
-        roundId,
-        rewards: viem.formatEther(BigInt(data[0]))
-      })
-    }
-  });
-};
-
-// src/hooks/thor/contracts/X2EarnApps/utils/getXAppMetadata.ts
-var getXAppMetadata = async (uri, networkType) => {
-  const url = chunkLMX37RCG_cjs.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(
-    chunkLMX37RCG_cjs.getConfig(networkType).x2EarnAppsContractAddress,
-    chunk5GZ7N47F_cjs.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 = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
-var method7 = "getAppsOfRound";
-var getRoundXApps = async (thor, networkType, roundId) => {
-  if (!roundId) return [];
-  const [xApps] = await chunkLMX37RCG_cjs.executeCallClause({
-    thor,
-    contractAddress: chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = chunkLMX37RCG_cjs.getConfig(network).xAllocationVotingContractAddress;
-  const eventAbi = thor.contracts.load(xAllocationVotingContract, chunk5GZ7N47F_cjs.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: chunkLMX37RCG_cjs.getConfig(network).nodeUrl
-  });
-  const decodedAllocatedVoteEvents = [];
-  events.forEach((event) => {
-    if (!event.decodedData) {
-      throw new Error("Event data not decoded");
-    }
-    if (!chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = React10.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 reactQuery.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.useQuery({
-    queryKey: getXAppsSharesQueryKey(roundId),
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        chunkLMX37RCG_cjs.getConfig(network.type).xAllocationPoolContractAddress,
-        chunk5GZ7N47F_cjs.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 = React10.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 = chunk5GZ7N47F_cjs.X2EarnApps__factory.abi;
-var method8 = "baseURI";
-var getXAppsMetadataBaseUriQueryKey = (network) => getCallClauseQueryKeyWithArgs({
-  abi: abi5,
-  method: method8,
-  address: chunkLMX37RCG_cjs.getConfig(network).x2EarnAppsContractAddress,
-  args: []
-});
-var useXAppsMetadataBaseUri = () => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi5,
-    address: chunkLMX37RCG_cjs.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(
-    chunkLMX37RCG_cjs.getConfig(networkType).xAllocationPoolContractAddress,
-    chunk5GZ7N47F_cjs.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: viem.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 = dappKitReact.useThor();
-  const queryClient = getOrCreateQueryClient();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = dappKitReact.useThor();
-  const queryClient = getOrCreateQueryClient();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.useQuery({
-    queryKey: getXAppRoundEarningsQueryKey(roundId, "ALL"),
-    queryFn: async () => {
-      const data = await queryClient.ensureQueryData({
-        queryFn: () => getRoundXApps(thor, network.type, roundId),
-        queryKey: getRoundXAppsQueryKey(roundId)
-      });
-      const xAllocationPoolContract = chunkLMX37RCG_cjs.getConfig(
-        network.type
-      ).xAllocationPoolContractAddress;
-      const xAppsInRound = data.filter((app) => xAppIds.includes(app.id));
-      const contract = thor.contracts.load(
-        xAllocationPoolContract,
-        chunk5GZ7N47F_cjs.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 = viem.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  const queryClient = getOrCreateQueryClient();
-  const lastRound = roundIds[roundIds.length - 1] ?? 0;
-  return reactQuery.useQuery({
-    queryKey: getXAppTotalEarningsQueryKey(lastRound, appId),
-    queryFn: async () => {
-      const contract = thor.contracts.load(
-        chunkLMX37RCG_cjs.getConfig(network.type).xAllocationPoolContractAddress,
-        chunk5GZ7N47F_cjs.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 = viem.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 = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
-var method9 = "state";
-var getAllocationsRoundStateQueryKey = (roundId, network) => getCallClauseQueryKeyWithArgs({
-  abi: abi6,
-  method: method9,
-  address: chunkLMX37RCG_cjs.getConfig(network).xAllocationVotingContractAddress,
-  args: [BigInt(roundId || 0)]
-});
-var useAllocationsRoundState = (roundId) => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi6,
-    address: chunkLMX37RCG_cjs.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 = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
-var method10 = "currentRoundId";
-var getCurrentAllocationsRoundIdQueryKey = (network) => getCallClauseQueryKeyWithArgs({
-  abi: abi7,
-  method: method10,
-  address: chunkLMX37RCG_cjs.getConfig(network).xAllocationVotingContractAddress,
-  args: []
-});
-var useCurrentAllocationsRoundId = () => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi7,
-    address: chunkLMX37RCG_cjs.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 = chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi;
-var getHasVotedInRoundQueryKey = (roundId, address, networkType) => getCallClauseQueryKeyWithArgs({
-  abi: abi8,
-  address: chunkLMX37RCG_cjs.getConfig(networkType).xAllocationVotingContractAddress,
-  method: method11,
-  args: [BigInt(roundId || 0), address]
-});
-var useHasVotedInRound = (roundId, address) => {
-  const { network } = useVeChainKitConfig();
-  return useCallClause({
-    abi: abi8,
-    address: chunkLMX37RCG_cjs.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 = chunkLMX37RCG_cjs.getConfig(networkType).xAllocationVotingContractAddress;
-  const eventAbi = thor.contracts.load(xAllocationVotingContract, chunk5GZ7N47F_cjs.XAllocationVoting__factory.abi).getEventAbi("RoundCreated");
-  const events = await getAllEventLogs({
-    thor,
-    filterCriteria: [
-      {
-        criteria: {
-          address: xAllocationVotingContract,
-          topic0: eventAbi.signatureHash
-        },
-        eventAbi
-      }
-    ],
-    nodeUrl: chunkLMX37RCG_cjs.getConfig(networkType).nodeUrl
-  });
-  const decodedCreatedAllocationEvents = [];
-  events.forEach((event) => {
-    if (!event.decodedData) {
-      throw new Error("Event data not decoded");
-    }
-    if (!chunkLMX37RCG_cjs.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 = dappKitReact.useThor();
-  const { network } = useVeChainKitConfig();
-  return reactQuery.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 = React10.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 = chunkLMX37RCG_cjs.getConfig(network.type).network.blockTime;
-  const estimatedEndTime = React10.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 = React10.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 = chunk5GZ7N47F_cjs.XAllocationVotingGovernor__factory.abi;
-var method12 = "getAppVotes";
-var getXAppVotesQueryKey = (networkType, roundId, appId) => getCallClauseQueryKeyWithArgs({
-  abi: contractAbi5,
-  address: chunkLMX37RCG_cjs.getConfig(networkType).xAllocationVotingContractAddress,
-  method: method12,
-  args: [BigInt(roundId || 0), appId]
-});
-var useXAppVotes = (roundId, appId) => {
-  const { network } = useVeChainKitConfig();
-  const contractAddress = chunkLMX37RCG_cjs.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) => viem.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 = dappKitReact.useThor();
   const { signer } = dappKitReact.useWallet();
   const { connection } = useWallet();
@@ -19216,16 +18274,14 @@ var AddressDisplayCard = ({
 }) => {
   const { darkMode: isDark } = useVeChainKitConfig();
   const { t } = reactI18next.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 = React10.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 = React10.useMemo(() => {
     if (balance !== void 0) return balance;
     if (tokenData) {
@@ -20495,7 +19551,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) {
@@ -20523,7 +19579,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(
@@ -20588,7 +19644,7 @@ var VeChainKitProvider = (props) => {
   const validatedLoginMethods = loginMethods;
   const allowedEcosystemApps = React10.useMemo(() => {
     const userEcosystemMethods = validatedLoginMethods?.find(
-      (method13) => method13.method === "ecosystem"
+      (method7) => method7.method === "ecosystem"
     );
     return userEcosystemMethods?.allowedApps ?? chunkLMX37RCG_cjs.DEFAULT_PRIVY_ECOSYSTEM_APPS.map((app) => app.id);
   }, [validatedLoginMethods]);
@@ -21265,7 +20321,6 @@ exports.ProfileModalProvider = ProfileModalProvider;
 exports.QuickActionsSection = QuickActionsSection;
 exports.ReceiveModalProvider = ReceiveModalProvider;
 exports.ReceiveTokenContent = ReceiveTokenContent;
-exports.RoundState = RoundState;
 exports.ScrollToTopWrapper = ScrollToTopWrapper;
 exports.SelectTokenContent = SelectTokenContent;
 exports.SendTokenContent = SendTokenContent;
@@ -21309,9 +20364,6 @@ exports.getAccountImplementationAddress = getAccountImplementationAddress;
 exports.getAccountImplementationAddressQueryKey = getAccountImplementationAddressQueryKey;
 exports.getAccountVersionQueryKey = getAccountVersionQueryKey;
 exports.getAllEventLogs = getAllEventLogs;
-exports.getAllocationsRoundStateQueryKey = getAllocationsRoundStateQueryKey;
-exports.getAllocationsRoundsEvents = getAllocationsRoundsEvents;
-exports.getAllocationsRoundsEventsQueryKey = getAllocationsRoundsEventsQueryKey;
 exports.getAppHubAppsQueryKey = getAppHubAppsQueryKey;
 exports.getAvatar = getAvatar;
 exports.getAvatarLegacy = getAvatarLegacy;
@@ -21338,7 +20390,6 @@ exports.getErc20BalanceQueryKey = getErc20BalanceQueryKey;
 exports.getEventLogs = getEventLogs;
 exports.getHasV1SmartAccount = getHasV1SmartAccount;
 exports.getHasV1SmartAccountQueryKey = getHasV1SmartAccountQueryKey;
-exports.getHasVotedInRoundQueryKey = getHasVotedInRoundQueryKey;
 exports.getIpfsImage = getIpfsImage;
 exports.getIpfsImageQueryKey = getIpfsImageQueryKey;
 exports.getIpfsMetadata = getIpfsMetadata;
@@ -21346,12 +20397,9 @@ exports.getIpfsMetadataQueryKey = getIpfsMetadataQueryKey;
 exports.getIsDeployed = getIsDeployed;
 exports.getIsDeployedQueryKey = getIsDeployedQueryKey;
 exports.getIsDomainProtectedQueryKey = getIsDomainProtectedQueryKey;
-exports.getIsPersonAtTimepointQueryKey = getIsPersonAtTimepointQueryKey;
 exports.getIsPersonQueryKey = getIsPersonQueryKey;
 exports.getPrivyAppInfoQueryKey = getPrivyAppInfoQueryKey;
 exports.getResolverAddressQueryKey = getResolverAddressQueryKey;
-exports.getRoundRewardQueryKey = getRoundRewardQueryKey;
-exports.getRoundXApps = getRoundXApps;
 exports.getRoundXAppsQueryKey = getRoundXAppsQueryKey;
 exports.getSmartAccount = getSmartAccount;
 exports.getSmartAccountQueryKey = getSmartAccountQueryKey;
@@ -21360,32 +20408,16 @@ exports.getTextRecordsQueryKey = getTextRecordsQueryKey;
 exports.getTokenInfo = getTokenInfo;
 exports.getTokenUsdPrice = getTokenUsdPrice;
 exports.getTokenUsdPriceQueryKey = getTokenUsdPriceQueryKey;
-exports.getTokensInfoByOwnerQueryKey = getTokensInfoByOwnerQueryKey;
 exports.getUpgradeRequired = getUpgradeRequired;
 exports.getUpgradeRequiredForAccount = getUpgradeRequiredForAccount;
 exports.getUpgradeRequiredForAccountQueryKey = getUpgradeRequiredForAccountQueryKey;
 exports.getUpgradeRequiredQueryKey = getUpgradeRequiredQueryKey;
-exports.getUserBotSignalsQueryKey = getUserBotSignalsQueryKey;
-exports.getUserNodesQueryKey = getUserNodesQueryKey;
-exports.getUserVotesInRound = getUserVotesInRound;
-exports.getUserVotesInRoundQueryKey = getUserVotesInRoundQueryKey;
-exports.getVeDelegateBalance = getVeDelegateBalance;
-exports.getVeDelegateBalanceQueryKey = getVeDelegateBalanceQueryKey;
 exports.getVechainDomainQueryKey = getVechainDomainQueryKey;
 exports.getVersion = getVersion;
 exports.getVersionQueryKey = getVersionQueryKey;
 exports.getVot3Balance = getVot3Balance;
 exports.getVot3BalanceQueryKey = getVot3BalanceQueryKey;
-exports.getVotesInRoundQueryKey = getVotesInRoundQueryKey;
 exports.getXAppMetadata = getXAppMetadata;
-exports.getXAppMetadataQueryKey = getXAppMetadataQueryKey;
-exports.getXAppRoundEarnings = getXAppRoundEarnings;
-exports.getXAppRoundEarningsQueryKey = getXAppRoundEarningsQueryKey;
-exports.getXAppTotalEarningsQueryKey = getXAppTotalEarningsQueryKey;
-exports.getXAppVotesQueryKey = getXAppVotesQueryKey;
-exports.getXApps = getXApps;
-exports.getXAppsMetadataBaseUriQueryKey = getXAppsMetadataBaseUriQueryKey;
-exports.getXAppsQueryKey = getXAppsQueryKey;
 exports.getXAppsSharesQueryKey = getXAppsSharesQueryKey;
 exports.imageCompressionOptions = imageCompressionOptions;
 exports.txReceiptQueryKey = txReceiptQueryKey;
@@ -21394,9 +20426,6 @@ exports.useAccountBalance = useAccountBalance;
 exports.useAccountCustomizationModal = useAccountCustomizationModal;
 exports.useAccountImplementationAddress = useAccountImplementationAddress;
 exports.useAccountModal = useAccountModal;
-exports.useAllocationsRound = useAllocationsRound;
-exports.useAllocationsRoundState = useAllocationsRoundState;
-exports.useAllocationsRoundsEvents = useAllocationsRoundsEvents;
 exports.useAppHubApps = useAppHubApps;
 exports.useBuildTransaction = useBuildTransaction;
 exports.useCallClause = useCallClause;
@@ -21407,7 +20436,6 @@ exports.useConnectModal = useConnectModal;
 exports.useCrossAppConnectionCache = useCrossAppConnectionCache;
 exports.useCurrency = useCurrency;
 exports.useCurrentAccountImplementationVersion = useCurrentAccountImplementationVersion;
-exports.useCurrentAllocationsRound = useCurrentAllocationsRound;
 exports.useCurrentAllocationsRoundId = useCurrentAllocationsRoundId;
 exports.useCurrentBlock = useCurrentBlock;
 exports.useCustomTokens = useCustomTokens;
@@ -21418,7 +20446,6 @@ exports.useFAQModal = useFAQModal;
 exports.useFeatureAnnouncement = useFeatureAnnouncement;
 exports.useFetchAppInfo = useFetchAppInfo;
 exports.useFetchPrivyStatus = useFetchPrivyStatus;
-exports.useGalaxyMemberTokensInfo = useGalaxyMemberTokensInfo;
 exports.useGetAccountAddress = useGetAccountAddress;
 exports.useGetAccountVersion = useGetAccountVersion;
 exports.useGetAvatar = useGetAvatar;
@@ -21434,12 +20461,8 @@ exports.useGetNodeUrl = useGetNodeUrl;
 exports.useGetResolverAddress = useGetResolverAddress;
 exports.useGetTextRecords = useGetTextRecords;
 exports.useGetTokenUsdPrice = useGetTokenUsdPrice;
-exports.useGetUserNode = useGetUserNode;
-exports.useGetUserNodes = useGetUserNodes;
-exports.useGetVeDelegateBalance = useGetVeDelegateBalance;
 exports.useGetVot3Balance = useGetVot3Balance;
 exports.useHasV1SmartAccount = useHasV1SmartAccount;
-exports.useHasVotedInRound = useHasVotedInRound;
 exports.useIpfsImage = useIpfsImage;
 exports.useIpfsImageList = useIpfsImageList;
 exports.useIpfsMetadata = useIpfsMetadata;
@@ -21447,9 +20470,7 @@ exports.useIpfsMetadatas = useIpfsMetadatas;
 exports.useIsDomainProtected = useIsDomainProtected;
 exports.useIsPWA = useIsPWA;
 exports.useIsPerson = useIsPerson;
-exports.useIsPersonAtTimepoint = useIsPersonAtTimepoint;
 exports.useIsSmartAccountDeployed = useIsSmartAccountDeployed;
-exports.useIsUserPerson = useIsUserPerson;
 exports.useLegalDocuments = useLegalDocuments;
 exports.useLocalStorage = useLocalStorage;
 exports.useLoginModalContent = useLoginModalContent;
@@ -21457,7 +20478,6 @@ exports.useLoginWithOAuth = useLoginWithOAuth2;
 exports.useLoginWithPasskey = useLoginWithPasskey;
 exports.useLoginWithVeChain = useLoginWithVeChain;
 exports.useMostVotedAppsInRound = useMostVotedAppsInRound;
-exports.useMultipleXAppRoundEarnings = useMultipleXAppRoundEarnings;
 exports.useNotificationAlerts = useNotificationAlerts;
 exports.useNotifications = useNotifications;
 exports.useNotificationsModal = useNotificationsModal;
@@ -21468,7 +20488,6 @@ exports.useRefreshBalances = useRefreshBalances;
 exports.useRefreshFactoryQueries = useRefreshFactoryQueries;
 exports.useRefreshMetadata = useRefreshMetadata;
 exports.useRefreshSmartAccountQueries = useRefreshSmartAccountQueries;
-exports.useRoundReward = useRoundReward;
 exports.useRoundXApps = useRoundXApps;
 exports.useScrollToTop = useScrollToTop;
 exports.useSendTokenModal = useSendTokenModal;
@@ -21480,9 +20499,7 @@ exports.useSmartAccount = useSmartAccount;
 exports.useSmartAccountVersion = useSmartAccountVersion;
 exports.useSyncableLocalStorage = useSyncableLocalStorage;
 exports.useTokenBalances = useTokenBalances;
-exports.useTokenBalances2 = useTokenBalances2;
 exports.useTokenPrices = useTokenPrices;
-exports.useTokenPrices2 = useTokenPrices2;
 exports.useTokensWithValues = useTokensWithValues;
 exports.useTotalBalance = useTotalBalance;
 exports.useTransactionModal = useTransactionModal;
@@ -21497,22 +20514,12 @@ exports.useUpgradeRequiredForAccount = useUpgradeRequiredForAccount;
 exports.useUpgradeSmartAccount = useUpgradeSmartAccount;
 exports.useUpgradeSmartAccountModal = useUpgradeSmartAccountModal;
 exports.useUploadImages = useUploadImages;
-exports.useUserBotSignals = useUserBotSignals;
-exports.useUserVotesInRound = useUserVotesInRound;
 exports.useVeChainKitConfig = useVeChainKitConfig;
 exports.useVechainDomain = useVechainDomain;
-exports.useVotesInRound = useVotesInRound;
-exports.useVotingRewards = useVotingRewards;
 exports.useWallet = useWallet;
 exports.useWalletMetadata = useWalletMetadata;
 exports.useWalletModal = useWalletModal2;
-exports.useXApp = useXApp;
 exports.useXAppMetadata = useXAppMetadata;
-exports.useXAppRoundEarnings = useXAppRoundEarnings;
-exports.useXAppTotalEarnings = useXAppTotalEarnings;
-exports.useXAppVotes = useXAppVotes;
-exports.useXApps = useXApps;
-exports.useXAppsMetadataBaseUri = useXAppsMetadataBaseUri;
 exports.useXAppsShares = useXAppsShares;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map