@vechain/vechain-kit 2.0.0-rc.9 → 2.0.1

package/dist/index-ur27qfX4.d.cts

@@ -0,0 +1,3965 @@
+import { ButtonProps, IconButtonProps, ImageProps, PropsOf, StackProps, ThemeTypings, VStack } from "@chakra-ui/react";
+import * as react0 from "react";
+import React$1, { ElementType, ReactElement, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _vechain_sdk_network0 from "@vechain/sdk-network";
+import { CompressedBlockDetail, EventLogs, FilterEventLogsOptions, ThorClient, ThorClient as ThorClient$1, TransactionReceipt } from "@vechain/sdk-network";
+import { LoginMethodOrderOption, OAuthProviderType, SignTypedDataParams, User, WalletListEntry, useMfaEnrollment, usePrivy, useSetWalletRecovery } from "@privy-io/react-auth";
+import * as _vechain_sdk_core0 from "@vechain/sdk-core";
+import { Address, Certificate, CertificateData, Clause, Transaction, TransactionClause } from "@vechain/sdk-core";
+import { LogLevel, WalletSource } from "@vechain/dapp-kit";
+import { WalletButton as DAppKitWalletButton, WalletConnectOptions, useThor, useWallet as useDAppKitWallet, useWalletModal as useDAppKitWalletModal } from "@vechain/dapp-kit-react";
+import { CustomizedStyle, I18n, SourceInfo } from "@vechain/dapp-kit-ui";
+import { IconType } from "react-icons";
+import * as _tanstack_react_query8 from "@tanstack/react-query";
+import { UseQueryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+import { CustomTokenInfo } from "@vechain/contract-getters";
+import { Options } from "browser-image-compression";
+import { Account } from "viem/accounts";
+import * as abitype0 from "abitype";
+import { AbiParametersToPrimitiveTypes, ExtractAbiFunction, ExtractAbiFunctionNames } from "abitype";
+import { Abi, ContractEventName, ContractFunctionParameters, MulticallParameters, MulticallReturnType, decodeEventLog } from "viem";
+import { UseFormRegister } from "react-hook-form";
+
+//#region src/config/network.d.ts
+/**
+ * The type of network that we are connected to (indentified by the genesis block)
+ * */
+type NETWORK_TYPE = 'main' | 'test' | 'solo';
+/**
+ * A model for the VechainThor network that we are connected to
+ * @field `id` - Unique ID for this network
+ * @field `defaultNet` - If the network is a default network
+ * @field `name` - A name for this network
+ * @field `type` - What type of network is it? `main, test, solo or custom`
+ * @field `urls` - A list of URLs for this network
+ * @field `currentUrl` - The current URL that we are connected to
+ * @field `explorerUrl` - The explorer URL for this network
+ * @field `genesis` - The genesis block for the network
+ * @field `blockTime` - The time it takes to mine a block in milliseconds
+ */
+type Network = {
+  id: string;
+  defaultNet: boolean;
+  name: string;
+  type: NETWORK_TYPE;
+  urls: string[];
+  explorerUrl?: string;
+  genesis: typeof genesises.main;
+  blockTime: number;
+};
+declare const genesises: {
+  readonly main: CompressedBlockDetail;
+  readonly test: CompressedBlockDetail;
+  readonly solo: CompressedBlockDetail;
+  which(gid: string): "main" | "test" | "solo" | undefined;
+};
+//#endregion
+//#region src/types/types.d.ts
+type TokenBalance = {
+  original: string;
+  scaled: string;
+  formatted: string;
+};
+type ENSRecords = {
+  display?: string;
+  description?: string;
+  email?: string;
+  url?: string;
+  header?: string;
+  notice?: string;
+  location?: string;
+  phone?: string;
+  [key: string]: string | undefined;
+};
+type Wallet = {
+  address: string;
+  domain?: string;
+  image?: string;
+  isLoadingMetadata?: boolean;
+  metadata?: ENSRecords;
+} | null;
+type SmartAccount = Wallet & {
+  isDeployed: boolean;
+  isActive: boolean;
+  version: number | null;
+};
+type ConnectionSource = {
+  type: 'privy' | 'wallet' | 'privy-cross-app';
+  displayName: string;
+};
+/**
+ * Data that the Privy user must sign in order to execute a transaction
+ * by authorizing the Smart Account contract
+ */
+type ExecuteWithAuthorizationSignData = {
+  domain: {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+  };
+  types: {
+    ExecuteWithAuthorization: {
+      name: string;
+      type: string;
+    }[];
+    EIP712Domain: {
+      name: string;
+      type: string;
+    }[];
+  };
+  primaryType: string;
+  message: {
+    validAfter: number;
+    validBefore: number;
+    to: string | null | undefined;
+    value: string;
+    data: string;
+  };
+};
+type ExecuteBatchWithAuthorizationSignData = {
+  domain: {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+  };
+  types: {
+    ExecuteBatchWithAuthorization: {
+      name: string;
+      type: string;
+    }[];
+    EIP712Domain: {
+      name: string;
+      type: string;
+    }[];
+  };
+  primaryType: string;
+  message: {
+    to: string[] | null | undefined;
+    value: string[] | null | undefined;
+    data: string[] | null | undefined;
+    validAfter: number;
+    validBefore: number;
+    nonce: string;
+  };
+};
+/**
+ * ready: the user has not clicked on the button yet
+ * pending: the user has clicked on the button and we're waiting for the transaction to be sent
+ * waitingConfirmation: the transaction has been sent and we're waiting for the transaction to be confirmed by the chain
+ * success: the transaction has been confirmed by the chain
+ * error: the transaction has failed
+ * unknown: the transaction receipt has failed to load
+ */
+type TransactionStatus = 'ready' | 'pending' | 'waitingConfirmation' | 'success' | 'error' | 'unknown';
+type TransactionStatusErrorType = {
+  type: 'SendTransactionError' | 'TxReceiptError' | 'RevertReasonError' | 'UserRejectedError';
+  reason?: string;
+};
+/**
+ * An enhanced clause with a comment and an abi
+ * @param comment a comment to add to the clause
+ * @param abi the abi of the contract to call
+ */
+type EnhancedClause = TransactionClause;
+type PrivyAppInfo = {
+  id: string;
+  name: string;
+  logo_url: string;
+  icon_url: string | null;
+  terms_and_conditions_url: string;
+  privacy_policy_url: string;
+  theme: string;
+  accent_color: string;
+  wallet_auth: boolean;
+  email_auth: boolean;
+  google_oauth: boolean;
+  twitter_oauth: boolean;
+  url: string;
+  website?: string;
+};
+type PrivyLoginMethod = LoginMethodOrderOption;
+interface CrossAppConnectionCache {
+  timestamp: number;
+  ecosystemApp: {
+    name: string;
+    logoUrl?: string;
+    appId: string;
+    website?: string;
+  };
+}
+declare enum NFTMediaType {
+  IMAGE = "image",
+  VIDEO = "video",
+  UNKNOWN = "unknown",
+  TEXT = "text",
+}
+declare enum VePassportUserStatus {
+  NONE = "NONE",
+  WHITELIST = "WHITELIST",
+  BLACKLIST = "BLACKLIST",
+}
+type CURRENCY = 'usd' | 'gbp' | 'eur';
+declare const CURRENCY_SYMBOLS: Record<CURRENCY, string>;
+//#endregion
+//#region src/types/ensTextRecords.d.ts
+declare const ENS_TEXT_RECORDS: readonly ["display", "avatar", "description", "keywords", "email", "url", "header", "notice", "location", "phone", "com.x"];
+type TextRecords = { [K in (typeof ENS_TEXT_RECORDS)[number]]?: string };
+//#endregion
+//#region src/types/gasToken.d.ts
+type GasTokenType = 'B3TR' | 'VET' | 'VTHO';
+type TransactionSpeed = 'regular' | 'medium' | 'high';
+interface GasTokenInfo {
+  type: GasTokenType;
+  name: string;
+  symbol: string;
+  address?: string;
+  description: string;
+}
+interface GasTokenPreferences {
+  tokenPriority: GasTokenType[];
+  availableGasTokens: GasTokenType[];
+  excludedTokens: GasTokenType[];
+  alwaysConfirm: boolean;
+  gasTokenToUse: GasTokenType;
+}
+interface GasTokenEstimate {
+  token: GasTokenType;
+  cost: string;
+  available: boolean;
+  balance?: string;
+}
+interface GasTokenSelection {
+  selectedToken: GasTokenType;
+  cost: string;
+  hasServiceFee: boolean;
+}
+//#endregion
+//#region src/types/gasEstimation.d.ts
+interface VthoPerGasAtSpeed {
+  regular: number;
+  medium: number;
+  high: number;
+  legacy: number;
+}
+interface EstimatedGas {
+  vtho: number;
+  vet: number;
+  b3tr: number;
+  smartAccount: number;
+}
+interface Rate {
+  vtho: number;
+  vet: number;
+  b3tr: number;
+}
+interface CostLevel {
+  vtho: number;
+  vet: number;
+  b3tr: number;
+  vetWithSmartAccount: number;
+  b3trWithSmartAccount: number;
+}
+interface TransactionCost {
+  regular: CostLevel;
+  medium: CostLevel;
+  high: CostLevel;
+  legacy: CostLevel;
+}
+interface EstimationResponse {
+  vthoPerGasAtSpeed?: number;
+  estimatedGas?: number;
+  rate?: number;
+  transactionCost?: number;
+  serviceFee?: number;
+  totalGasUsed?: number;
+}
+interface DepositAccount {
+  depositAccount: string;
+}
+declare function calculateTotalCost(baseCost: number, serviceFeeRate: number): number;
+declare function formatGasCost(amount: number, decimals?: number): string;
+//#endregion
+//#region src/types/index.d.ts
+declare enum LegalDocumentType {
+  TERMS = "terms",
+  PRIVACY = "privacy",
+  COOKIES = "cookies",
+}
+declare enum LegalDocumentSource {
+  VECHAIN_KIT = "vechain-kit",
+  APPLICATION = "application",
+}
+type EnrichedLegalDocument = LegalDocument & {
+  id: string;
+  documentType: LegalDocumentType;
+  documentSource: LegalDocumentSource;
+};
+type LegalDocumentAgreement = EnrichedLegalDocument & {
+  walletAddress: string;
+  timestamp: number;
+};
+//#endregion
+//#region src/theme/tokens.d.ts
+/**
+ * Theme token system for VeChain Kit
+ * Provides a single source of truth for all styling values
+ */
+/**
+ * Complete internal token type - all fields required
+ */
+interface ThemeTokens {
+  colors: {
+    background: {
+      modal: string;
+      overlay: string;
+      card: string;
+      cardElevated: string;
+      stickyHeader: string;
+    };
+    text: {
+      primary: string;
+      secondary: string;
+      tertiary: string;
+      disabled: string;
+    };
+    border: {
+      default: string;
+      hover: string;
+      focus: string;
+      button: string;
+    };
+    success: string;
+    error: string;
+    warning: string;
+  };
+  buttons: {
+    button: {
+      bg: string;
+      color: string;
+      border: string;
+      hoverBg?: string;
+    };
+    primaryButton: {
+      bg: string;
+      color: string;
+      border: string;
+      hoverBg?: string;
+    };
+    tertiaryButton: {
+      bg: string;
+      color: string;
+      border: string;
+    };
+    loginButton: {
+      bg: string;
+      color: string;
+      border: string;
+    };
+  };
+  effects: {
+    backdropFilter: {
+      modal: string;
+      overlay: string;
+      stickyHeader: string;
+    };
+    glassOpacity: {
+      modal: number;
+      overlay: number;
+      stickyHeader: number;
+    };
+  };
+  fonts: {
+    body: string;
+    heading: string;
+    sizes: {
+      small: string;
+      medium: string;
+      large: string;
+    };
+    weights: {
+      normal: number;
+      medium: number;
+      bold: number;
+    };
+  };
+  borders: {
+    radius: {
+      small: string;
+      medium: string;
+      large: string;
+      xl: string;
+      full: string;
+    };
+  };
+}
+/**
+ * Developer-facing theme configuration
+ * Simplified interface - only backgroundColor and textColor required
+ * All other colors are automatically derived from these base colors
+ */
+interface VechainKitThemeConfig {
+  backgroundColor?: string;
+  textColor?: string;
+  overlay?: {
+    backgroundColor?: string;
+    blur?: string;
+  };
+  buttons?: {
+    secondaryButton?: {
+      bg?: string;
+      color?: string;
+      border?: string;
+      hoverBg?: string;
+    };
+    primaryButton?: {
+      bg?: string;
+      color?: string;
+      border?: string;
+      hoverBg?: string;
+    };
+    tertiaryButton?: {
+      bg?: string;
+      color?: string;
+      border?: string;
+    };
+    loginButton?: {
+      bg?: string;
+      color?: string;
+      border?: string;
+    };
+  };
+  fonts?: {
+    family?: string;
+    body?: string;
+    heading?: string;
+    sizes?: {
+      small?: string;
+      medium?: string;
+      large?: string;
+    };
+    weights?: {
+      normal?: number;
+      medium?: number;
+      bold?: number;
+    };
+  };
+  effects?: {
+    glass?: {
+      enabled?: boolean;
+      intensity?: 'low' | 'medium' | 'high';
+    };
+    backdropFilter?: {
+      modal?: string;
+      overlay?: string;
+    };
+  };
+}
+//#endregion
+//#region src/providers/VeChainKitProvider.d.ts
+type AlwaysAvailableMethods = 'vechain' | 'dappkit' | 'ecosystem';
+type PrivyDependentMethods = 'email' | 'google' | 'github' | 'passkey' | 'more';
+type LoginMethodOrder = {
+  method: AlwaysAvailableMethods | (VechainKitProviderProps['privy'] extends undefined ? never : PrivyDependentMethods);
+  gridColumn?: number;
+  allowedApps?: string[];
+};
+type LegalDocumentOptions = {
+  privacyPolicy?: LegalDocument[];
+  termsAndConditions?: LegalDocument[];
+  cookiePolicy?: LegalDocument[];
+};
+type LegalDocument = {
+  url: string;
+  version: number;
+  required: boolean;
+  displayName?: string;
+};
+type VechainKitProviderProps = {
+  children: ReactNode;
+  privy?: {
+    appId: string;
+    clientId: string;
+    appearance: {
+      walletList?: WalletListEntry[];
+      accentColor?: `#${string}`;
+      loginMessage: string;
+      logo: string;
+    };
+    embeddedWallets?: {
+      createOnLogin: 'users-without-wallets' | 'all-users' | 'off';
+    };
+    loginMethods: PrivyLoginMethod[];
+  };
+  feeDelegation?: {
+    delegatorUrl?: string;
+    delegateAllTransactions?: boolean;
+    genericDelegatorUrl?: string;
+    b3trTransfers?: {
+      minAmountInEther: number;
+    };
+  };
+  dappKit: {
+    allowedWallets?: WalletSource[];
+    walletConnectOptions?: WalletConnectOptions;
+    usePersistence?: boolean;
+    useFirstDetectedSource?: boolean;
+    logLevel?: LogLevel;
+    themeVariables?: CustomizedStyle;
+    modalParent?: HTMLElement;
+    onSourceClick?: (source?: SourceInfo) => void;
+    v2Api?: {
+      enabled?: boolean;
+      external?: boolean;
+    };
+  };
+  loginModalUI?: {
+    logo?: string;
+    description?: string;
+  };
+  loginMethods?: LoginMethodOrder[];
+  darkMode?: boolean;
+  i18n?: I18n;
+  language?: string;
+  network: {
+    type: NETWORK_TYPE;
+    nodeUrl?: string;
+    requireCertificate?: boolean;
+    connectionCertificate?: {
+      message?: Certificate;
+      options?: CertificateData;
+    };
+  };
+  allowCustomTokens?: boolean;
+  legalDocuments?: LegalDocumentOptions;
+  defaultCurrency?: CURRENCY;
+  theme?: VechainKitThemeConfig;
+};
+type VeChainKitConfig = {
+  privy?: VechainKitProviderProps['privy'];
+  privyEcosystemAppIDS: string[];
+  feeDelegation?: VechainKitProviderProps['feeDelegation'];
+  dappKit: VechainKitProviderProps['dappKit'];
+  loginModalUI?: VechainKitProviderProps['loginModalUI'];
+  loginMethods?: VechainKitProviderProps['loginMethods'];
+  darkMode: boolean;
+  i18n?: VechainKitProviderProps['i18n'];
+  language?: VechainKitProviderProps['language'];
+  network: VechainKitProviderProps['network'];
+  allowCustomTokens?: boolean;
+  legalDocuments?: VechainKitProviderProps['legalDocuments'];
+  defaultCurrency?: VechainKitProviderProps['defaultCurrency'];
+  theme?: VechainKitThemeConfig;
+};
+/**
+ * Context to store the Privy and DAppKit configs so that they can be used by the hooks/components
+ */
+declare const VeChainKitContext: react0.Context<VeChainKitConfig | null>;
+/**
+ * Hook to get the Privy and DAppKit configs
+ */
+declare const useVeChainKitConfig: () => VeChainKitConfig;
+/**
+ * Provider to wrap the application with Privy and DAppKit
+ */
+declare const VeChainKitProvider: (props: Omit<VechainKitProviderProps, "queryClient">) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/providers/PrivyWalletProvider.d.ts
+interface PrivyWalletProviderContextType {
+  accountFactory: string;
+  delegateAllTransactions: boolean;
+  sendTransaction: (tx: {
+    txClauses: TransactionClause[];
+    title?: string;
+    description?: string;
+    buttonText?: string;
+    currentGasToken?: GasTokenType;
+  }) => Promise<string>;
+  signTypedData: (data: SignTypedDataParams) => Promise<string>;
+  signMessage: (message: string) => Promise<string>;
+  exportWallet: () => Promise<void>;
+}
+/**
+ * This provider is responsible for retrieving the smart account address
+ * of a Privy wallet and providing the necessary context for the smart account.
+ * Upon initialization this provider will execute a few useEffect hooks to:
+ * - retrieve the smart account address of the embedded wallet
+ * - retrieve the chain id
+ * - check if the smart account is deployed
+ *
+ * It also provides a function to send transactions on vechain by asking the privy wallet
+ * to sign the transaction and then forwarding the transaction to the node api.
+ * When sending a transaction this provider will check if the smart account is deployed and if not,
+ * it will deploy it.
+ */
+declare const PrivyWalletProvider: ({
+  children,
+  nodeUrl,
+  delegatorUrl,
+  delegateAllTransactions,
+  genericDelegator
+}: {
+  children: React$1.ReactNode;
+  nodeUrl: string;
+  delegatorUrl?: string;
+  delegateAllTransactions: boolean;
+  genericDelegator?: boolean;
+}) => react_jsx_runtime0.JSX.Element;
+declare const usePrivyWalletProvider: () => PrivyWalletProviderContextType;
+//#endregion
+//#region src/providers/VechainKitThemeProvider.d.ts
+type Props$36 = {
+  children: ReactNode;
+  darkMode?: boolean;
+  theme?: VechainKitThemeConfig;
+};
+declare const useVechainKitThemeConfig: () => {
+  portalRootRef?: React.RefObject<HTMLDivElement | null>;
+  tokens?: ThemeTokens;
+};
+declare const ColorModeSync: ({
+  darkMode
+}: {
+  darkMode: boolean;
+}) => react_jsx_runtime0.JSX.Element;
+declare const VechainKitThemeProvider: ({
+  children,
+  darkMode,
+  theme: customTheme
+}: Props$36) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/providers/LegalDocumentsProvider.d.ts
+type Props$35 = {
+  children: Readonly<ReactNode>;
+};
+type LegalDocumentsContextType = {
+  hasAgreedToRequiredDocuments: boolean;
+  agreements: LegalDocumentAgreement[];
+  walletAddress?: string;
+  documents: EnrichedLegalDocument[];
+  documentsNotAgreed: EnrichedLegalDocument[];
+};
+declare const useLegalDocuments: () => LegalDocumentsContextType;
+declare const LegalDocumentsProvider: ({
+  children
+}: Props$35) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/ConnectModal.d.ts
+type Props$34 = {
+  isOpen: boolean;
+  onClose: () => void;
+};
+type ConnectModalContentsTypes = 'main' | 'email-verification' | 'faq';
+declare const ConnectModal: ({
+  isOpen,
+  onClose
+}: Props$34) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Contents/MainContent.d.ts
+type Props$33 = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<ConnectModalContentsTypes>>;
+  onClose: () => void;
+};
+declare const MainContent: ({
+  setCurrentContent,
+  onClose
+}: Props$33) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/ConnectionButton.d.ts
+interface ConnectionButtonProps {
+  isDark: boolean;
+  onClick: () => void;
+  text?: string;
+  icon?: IconType;
+  customIcon?: ReactElement;
+  rightIcon?: ReactElement;
+  style?: ButtonProps;
+  variant?: string;
+  iconWidth?: string;
+}
+declare const ConnectionButton: ({
+  onClick,
+  text,
+  icon,
+  customIcon,
+  rightIcon,
+  style,
+  variant,
+  iconWidth
+}: ConnectionButtonProps) => react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/ConnectModal/Components/EmailLoginButton.d.ts
+declare const EmailLoginButton: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/VeChainLoginButton.d.ts
+type Props$32 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const VeChainLoginButton: ({
+  isDark,
+  gridColumn
+}: Props$32) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/EcosystemButton.d.ts
+type Props$31 = {
+  isDark: boolean;
+  appsInfo: PrivyAppInfo[];
+  isLoading: boolean;
+  gridColumn?: number;
+};
+declare const EcosystemButton: ({
+  appsInfo,
+  isLoading
+}: Props$31) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/PrivyButton.d.ts
+type Props$30 = {
+  isDark: boolean;
+  onViewMoreLogin: () => void;
+  gridColumn?: number;
+};
+declare const PrivyButton: ({
+  isDark,
+  onViewMoreLogin,
+  gridColumn
+}: Props$30) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/LoginWithGoogleButton.d.ts
+type Props$29 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const LoginWithGoogleButton: ({
+  isDark,
+  gridColumn
+}: Props$29) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/PasskeyLoginButton.d.ts
+type Props$28 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const PasskeyLoginButton: ({
+  isDark,
+  gridColumn
+}: Props$28) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/DappKitButton.d.ts
+type Props$27 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const DappKitButton: ({
+  isDark,
+  gridColumn
+}: Props$27) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/VeChainWithPrivyLoginButton.d.ts
+type Props$26 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const VeChainWithPrivyLoginButton: ({
+  isDark,
+  gridColumn
+}: Props$26) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/Components/LoginWithGithubButton.d.ts
+type Props$25 = {
+  isDark: boolean;
+  gridColumn?: number;
+};
+declare const LoginWithGithubButton: ({
+  isDark,
+  gridColumn
+}: Props$25) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/ConnectModal/ConnectPopover.d.ts
+type ConnectPopoverProps = {
+  isLoading: boolean;
+  buttonStyle?: ButtonProps;
+};
+declare const ConnectPopover: ({
+  isLoading,
+  buttonStyle
+}: ConnectPopoverProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/WalletButton/types.d.ts
+type WalletDisplayVariant = 'icon' | 'iconAndDomain' | 'iconDomainAndAddress' | 'iconDomainAndAssets';
+//#endregion
+//#region src/components/WalletButton/WalletButton.d.ts
+type WalletButtonProps = {
+  mobileVariant?: WalletDisplayVariant;
+  desktopVariant?: WalletDisplayVariant;
+  buttonStyle?: ButtonProps;
+  connectionVariant?: 'modal' | 'popover';
+};
+declare const WalletButton: ({
+  mobileVariant,
+  desktopVariant,
+  buttonStyle,
+  connectionVariant
+}: WalletButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/WalletButton/SocialIcons.d.ts
+declare const SocialIcons: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/TransactionModal/TransactionModal.d.ts
+type TransactionModalProps = {
+  isOpen: boolean;
+  onClose: () => void;
+  onTryAgain: () => void;
+  status: TransactionStatus;
+  txReceipt: TransactionReceipt | null;
+  txError?: Error | TransactionStatusErrorType;
+  uiConfig?: {
+    isClosable?: boolean;
+    showShareOnSocials?: boolean;
+    showExplorerButton?: boolean;
+    loadingIcon?: ReactNode;
+    successIcon?: ReactNode;
+    errorIcon?: ReactNode;
+    title?: ReactNode;
+    description?: string;
+    showSocialButtons?: boolean;
+  };
+};
+declare const TransactionModal: ({
+  isOpen,
+  onClose,
+  status,
+  uiConfig,
+  txReceipt,
+  txError,
+  onTryAgain
+}: TransactionModalProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/TransactionModal/Components/ShareButtons.d.ts
+type Props$24 = {
+  descriptionEncoded: string;
+  url?: string;
+  facebookHashtag?: string;
+};
+declare const ShareButtons: ({
+  descriptionEncoded
+}: Props$24) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/TransactionModal/TransactionModalContent.d.ts
+declare const TransactionModalContent: ({
+  status,
+  uiConfig,
+  onTryAgain,
+  txReceipt,
+  txError,
+  onClose
+}: Omit<TransactionModalProps, "isOpen">) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/TransactionToast/TransactionToast.d.ts
+type TransactionToastProps = {
+  isOpen: boolean;
+  onClose: () => void;
+  status: TransactionStatus;
+  txReceipt: TransactionReceipt | null;
+  onTryAgain: () => void;
+  txError?: Error | TransactionStatusErrorType;
+  description?: string;
+};
+declare const TransactionToast: ({
+  isOpen,
+  onClose,
+  status,
+  txReceipt,
+  txError,
+  onTryAgain,
+  description
+}: TransactionToastProps) => react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/AccountModal/Contents/Account/AccountMainContent.d.ts
+type Props$23 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  onClose: () => void;
+  wallet: Wallet;
+};
+declare const AccountMainContent: ({
+  setCurrentContent,
+  wallet,
+  onClose
+}: Props$23) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Account/AccessAndSecurityContent.d.ts
+type Props$22 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const AccessAndSecurityContent: ({
+  setCurrentContent
+}: Props$22) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Account/SettingsContent.d.ts
+type SettingsContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  onLogoutSuccess: () => void;
+};
+declare const SettingsContent: ({
+  setCurrentContent,
+  onLogoutSuccess
+}: SettingsContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Account/EmbeddedWalletContent.d.ts
+type Props$21 = {
+  setCurrentContent: (content: AccountModalContentTypes) => void;
+};
+declare const EmbeddedWalletContent: ({
+  setCurrentContent
+}: Props$21) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Account/DisconnectConfirmContent.d.ts
+type DisconnectConfirmContentProps = {
+  onDisconnect: () => void;
+  onBack: () => void;
+  onClose?: () => void;
+  text?: string;
+  showCloseButton?: boolean;
+};
+declare const DisconnectConfirmContent: ({
+  onDisconnect,
+  onBack,
+  onClose,
+  showCloseButton,
+  text
+}: DisconnectConfirmContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/api/privy/useFetchAppInfo.d.ts
+declare const fetchPrivyAppInfo: (appId: string) => Promise<PrivyAppInfo>;
+declare const getPrivyAppInfoQueryKey: (appIds: string | string[]) => string[];
+declare const useFetchAppInfo: (appIds: string | string[]) => _tanstack_react_query8.UseQueryResult<{
+  [k: string]: {
+    website: string | undefined;
+    id: string;
+    name: string;
+    logo_url: string;
+    icon_url: string | null;
+    terms_and_conditions_url: string;
+    privacy_policy_url: string;
+    theme: string;
+    accent_color: string;
+    wallet_auth: boolean;
+    email_auth: boolean;
+    google_oauth: boolean;
+    twitter_oauth: boolean;
+    url: string;
+  };
+}, Error>;
+//#endregion
+//#region src/hooks/api/privy/useFetchPrivyStatus.d.ts
+declare const fetchPrivyStatus: () => Promise<string>;
+declare const useFetchPrivyStatus: () => _tanstack_react_query8.UseQueryResult<string, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useVechainDomain.d.ts
+interface VeChainDomainResult {
+  address?: string;
+  domain?: string;
+  isValidAddressOrDomain: boolean;
+  isPrimaryDomain: boolean;
+}
+declare const getVechainDomainQueryKey: (addressOrDomain?: string | null) => (string | null | undefined)[];
+declare const useVechainDomain: (addressOrDomain?: string | null) => _tanstack_react_query8.UseQueryResult<VeChainDomainResult, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useEnsRecordExists.d.ts
+declare const getEnsRecordExistsQueryKey: (name: string) => string[];
+declare const useEnsRecordExists: (name: string) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useClaimVeWorldSubdomain.d.ts
+type useClaimVeWorldSubdomainProps = {
+  subdomain: string;
+  domain: string;
+  onSuccess?: () => void;
+  onError?: () => void;
+  onSuccessMessageTitle?: number;
+  alreadyOwned?: boolean;
+};
+type useClaimVeWorldSubdomainReturnValue = {
+  sendTransaction: () => Promise<void>;
+  clauses: () => TransactionClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+/**
+ * Hook for claiming a .veworld.vet subdomain
+ *
+ * This hook specializes in handling subdomains in the .veworld.vet domain
+ */
+declare const useClaimVeWorldSubdomain: ({
+  subdomain,
+  domain,
+  onSuccess,
+  onError,
+  alreadyOwned
+}: useClaimVeWorldSubdomainProps) => useClaimVeWorldSubdomainReturnValue;
+//#endregion
+//#region src/hooks/api/vetDomains/useClaimVetDomain.d.ts
+type useClaimVetDomainProps = {
+  domain: string;
+  onSuccess?: () => void;
+  onError?: () => void;
+  onSuccessMessageTitle?: number;
+  alreadyOwned?: boolean;
+};
+type useClaimVetDomainReturnValue = {
+  sendTransaction: () => Promise<void>;
+  clauses: () => TransactionClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const buildVetDomainClauses: (domain: string, alreadyOwned: boolean, account: Wallet, network: VechainKitProviderProps["network"]) => TransactionClause[];
+/**
+ * Hook for claiming a .vet domain
+ *
+ * This hook specializes in handling primary .vet domains
+ */
+declare const useClaimVetDomain: ({
+  domain,
+  onSuccess,
+  onError,
+  alreadyOwned
+}: useClaimVetDomainProps) => useClaimVetDomainReturnValue;
+//#endregion
+//#region src/hooks/api/vetDomains/useIsDomainProtected.d.ts
+declare const getIsDomainProtectedQueryKey: (domain?: string) => (string | undefined)[];
+/**
+ * Custom hook to fetch the protection status of a VeChain domain.
+ *
+ * @param {string} [domain] - The domain to fetch the protection status for.
+ * @param {boolean} [enabled=true] - Flag to enable or disable the hook.
+ * @returns The result of the useQuery hook, with the protection status.
+ */
+declare const useIsDomainProtected: (domain?: string, enabled?: boolean) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetDomainsOfAddress.d.ts
+declare const DomainSchema: z.ZodObject<{
+  name: z.ZodString;
+}, z.core.$strip>;
+declare const DomainsResponseSchema: z.ZodObject<{
+  domains: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Domain = z.infer<typeof DomainSchema>;
+type DomainsResponse = z.infer<typeof DomainsResponseSchema>;
+/**
+ * Fetches all domains owned by an address
+ * @param networkType The network type
+ * @param address The owner's address
+ * @param parentDomain The parent domain (e.g., "veworld.vet")
+ * @returns The domains owned by the address
+ */
+declare const getDomainsOfAddress: (networkType: NETWORK_TYPE, address?: string, parentDomain?: string) => Promise<DomainsResponse>;
+declare const getDomainsOfAddressQueryKey: (address?: string, parentDomain?: string) => (string | undefined)[];
+/**
+ * Hook to fetch all domains owned by an address
+ * @param address The owner's address
+ * @param parentDomain The parent domain (e.g., "veworld.vet")
+ * @returns The domains owned by the address
+ */
+declare const useGetDomainsOfAddress: (address?: string, parentDomain?: string) => _tanstack_react_query8.UseQueryResult<{
+  domains: {
+    name: string;
+  }[];
+}, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetAvatar.d.ts
+declare const getAvatarQueryKey: (name: string, networkType: NETWORK_TYPE) => string[];
+/**
+ * Hook to fetch the avatar URL for a VET domain name
+ * @param name - The VET domain name
+ * @returns The resolved avatar URL
+ */
+declare const useGetAvatar: (name: string) => _tanstack_react_query8.UseQueryResult<string | null, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetTextRecords.d.ts
+/**
+ * Get text records for a VET domain from the contract
+ * @param nodeUrl The node URL to query
+ * @param network The network type
+ * @param domain The domain to get text records for. If not provided, will return empty object
+ * @returns Object containing text records in the form of {@link TextRecords}
+ */
+declare const getTextRecords: (nodeUrl: string, network: NETWORK_TYPE, domain?: string) => Promise<TextRecords>;
+declare const getTextRecordsQueryKey: (domain?: string, network?: NETWORK_TYPE) => (string | undefined)[];
+declare const useGetTextRecords: (domain?: string) => _tanstack_react_query8.UseQueryResult<TextRecords, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useUpdateTextRecord.d.ts
+type UpdateTextRecordVariables = {
+  domain: string;
+  key: string;
+  value: string;
+};
+type UseUpdateTextRecordProps = {
+  onSuccess?: () => void | Promise<void>;
+  onError?: (error?: Error) => void | Promise<void>;
+  signerAccountAddress?: string;
+  resolverAddress?: string;
+};
+type UseUpdateTextRecordReturnValue = {
+  sendTransaction: (params: UpdateTextRecordVariables[]) => Promise<void> | undefined;
+  clauses: (params: UpdateTextRecordVariables[]) => TransactionClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const buildClauses: (resolverAddress: string, params: UpdateTextRecordVariables[]) => TransactionClause[];
+declare const useUpdateTextRecord: ({
+  onSuccess,
+  onError,
+  signerAccountAddress,
+  resolverAddress
+}?: UseUpdateTextRecordProps) => UseUpdateTextRecordReturnValue;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetResolverAddress.d.ts
+declare const getResolverAddressQueryKey: (domain?: string) => (string | undefined)[];
+/**
+ * Hook to get resolver address for a VET domain
+ * @param domain The domain to get resolver for
+ * @returns The resolver address for the domain
+ */
+declare const useGetResolverAddress: (domain?: string) => _tanstack_react_query8.UseQueryResult<`0x${string}`, unknown>;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetAvatarOfAddress.d.ts
+declare const getAvatarOfAddressQueryKey: (address?: string) => (string | undefined)[];
+/**
+ * Hook to fetch the avatar for an address by first getting their domains
+ * and then fetching the avatar for the first domain found
+ * @param address The owner's address
+ * @returns The avatar URL for the address's primary domain
+ */
+declare const useGetAvatarOfAddress: (address?: string) => _tanstack_react_query8.UseQueryResult<string, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useGetAvatarLegacy.d.ts
+/**
+ * Fetches the avatar for a given VET domain name
+ * @param networkType - The network type ('main' or 'test')
+ * @param nodeUrl - The node URL
+ * @param name - The VET domain name
+ * @returns The avatar URL from the response
+ */
+declare const getAvatarLegacy: (networkType: NETWORK_TYPE, nodeUrl: string, name: string) => Promise<string | null>;
+declare const getAvatarLegacyQueryKey: (name: string, networkType: NETWORK_TYPE) => string[];
+/**
+ * Hook to fetch the avatar URL for a VET domain name
+ * @param name - The VET domain name
+ * @returns The resolved avatar URL
+ */
+declare const useGetAvatarLegacy: (name: string) => _tanstack_react_query8.UseQueryResult<string | null, Error>;
+//#endregion
+//#region src/hooks/api/vetDomains/useUnsetDomain.d.ts
+type useUnsetDomainProps = {
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+type useUnsetDomainReturnValue = {
+  sendTransaction: () => Promise<void>;
+  clauses: () => TransactionClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+/**
+ * Hook for unsetting any domain name (both .veworld.vet and .vet domains)
+ *
+ * This hook is a dedicated implementation for the unset functionality
+ * that was previously part of the claim hooks.
+ */
+declare const useUnsetDomain: ({
+  onSuccess,
+  onError
+}: useUnsetDomainProps) => useUnsetDomainReturnValue;
+//#endregion
+//#region src/hooks/api/wallet/useTokenBalances.d.ts
+type WalletTokenBalance = {
+  address: string;
+  symbol: string;
+  balance: string;
+};
+declare const useTokenBalances: (address?: string) => {
+  balances: WalletTokenBalance[];
+  isLoading: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useTokenPrices.d.ts
+type ExchangeRates = {
+  eurUsdPrice: number;
+  gbpUsdPrice: number;
+};
+declare const useTokenPrices: () => {
+  prices: {
+    [x: string]: number;
+  };
+  exchangeRates: ExchangeRates;
+  isLoading: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useTokensWithValues.d.ts
+type TokenWithValue = WalletTokenBalance & {
+  priceUsd: number;
+  valueUsd: number;
+  valueInCurrency: number;
+};
+type UseTokensWithValuesProps = {
+  address?: string;
+};
+declare const useTokensWithValues: ({
+  address
+}: UseTokensWithValuesProps) => {
+  tokens: {
+    priceUsd: number;
+    valueUsd: number;
+    valueInCurrency: number;
+    address: string;
+    symbol: string;
+    balance: string;
+  }[];
+  sortedTokens: {
+    priceUsd: number;
+    valueUsd: number;
+    valueInCurrency: number;
+    address: string;
+    symbol: string;
+    balance: string;
+  }[];
+  tokensWithBalance: {
+    priceUsd: number;
+    valueUsd: number;
+    valueInCurrency: number;
+    address: string;
+    symbol: string;
+    balance: string;
+  }[];
+  isLoading: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useTotalBalance.d.ts
+type UseTotalBalanceProps = {
+  address?: string;
+};
+declare const useTotalBalance: ({
+  address
+}: UseTotalBalanceProps) => {
+  totalBalanceInCurrency: number;
+  totalBalanceUsd: number;
+  formattedBalance: string;
+  isLoading: boolean;
+  hasAnyBalance: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useCurrentAllocationsRoundId.d.ts
+/**
+ * Returns the query key for fetching the current allocations round ID.
+ * @returns The query key for fetching the current allocations round ID.
+ */
+declare const getCurrentAllocationsRoundIdQueryKey: (address: string) => string[];
+/**
+ * Hook to get the current roundId of allocations voting
+ * @returns the current roundId of allocations voting
+ */
+declare const useCurrentAllocationsRoundId: () => _tanstack_react_query8.UseQueryResult<string, unknown>;
+//#endregion
+//#region src/hooks/api/wallet/useCustomTokens.d.ts
+declare const useCustomTokens: () => {
+  customTokens: CustomTokenInfo[];
+  addToken: (address: CustomTokenInfo["address"]) => Promise<void>;
+  removeToken: (address: string) => void;
+  isTokenIncluded: (address: string) => boolean;
+  isDefaultToken: (address: string) => boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useGetB3trBalance.d.ts
+declare const getB3trBalanceQueryKey: (address?: string) => (string | undefined)[];
+declare const useGetB3trBalance: (address?: string) => _tanstack_react_query8.UseQueryResult<{
+  original: string;
+  scaled: string;
+  formatted: string;
+}, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useGetCustomTokenBalances.d.ts
+type TokenWithBalance = CustomTokenInfo & TokenBalance;
+declare const getCustomTokenBalanceQueryKey: (tokenAddress?: string, address?: string) => (string | undefined)[];
+declare const useGetCustomTokenBalances: (address?: string) => _tanstack_react_query8.UseQueryResult<{
+  original: string;
+  scaled: string;
+  formatted: string;
+  name: string;
+  address: string;
+  decimals: string;
+  symbol: string;
+}, Error>[];
+//#endregion
+//#region src/hooks/api/wallet/useGetCustomTokenInfo.d.ts
+declare const getTokenInfo: (tokenAddress: string, networkUrl: string) => Promise<CustomTokenInfo>;
+declare const getCustomTokenInfoQueryKey: (tokenAddress: string) => string[];
+declare const useGetCustomTokenInfo: (tokenAddress: string) => _tanstack_react_query8.UseQueryResult<CustomTokenInfo, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useGetErc20Balance.d.ts
+declare const getErc20BalanceQueryKey: (tokenAddress: string, address?: string) => (string | undefined)[];
+declare const useGetErc20Balance: (tokenAddress: string, address?: string) => _tanstack_react_query8.UseQueryResult<{
+  original: string;
+  scaled: string;
+  formatted: string;
+}, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useGetTokenUsdPrice.d.ts
+declare const PRICE_FEED_IDS: {
+  readonly B3TR: "0x623374722d757364000000000000000000000000000000000000000000000000";
+  readonly VET: "0x7665742d75736400000000000000000000000000000000000000000000000000";
+  readonly VTHO: "0x7674686f2d757364000000000000000000000000000000000000000000000000";
+  readonly GBP: "0x6762702d75736400000000000000000000000000000000000000000000000000";
+  readonly EUR: "0x657572742d757364000000000000000000000000000000000000000000000000";
+};
+type SupportedToken = keyof typeof PRICE_FEED_IDS;
+declare const getTokenUsdPrice: (thor: ThorClient, token: SupportedToken, network: NETWORK_TYPE) => Promise<number>;
+declare const getTokenUsdPriceQueryKey: (token: SupportedToken) => string[];
+declare const useGetTokenUsdPrice: (token: SupportedToken) => _tanstack_react_query8.UseQueryResult<number, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useGetVot3Balance.d.ts
+declare const getVot3BalanceQueryKey: (address?: string) => (string | undefined)[];
+declare const useGetVot3Balance: (address?: string) => _tanstack_react_query8.UseQueryResult<{
+  original: string;
+  scaled: string;
+  formatted: string;
+}, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useIsPerson.d.ts
+/**
+ * Returns the query key for fetching the isPerson status.
+ * @param user - The user address.
+ * @param networkType - The network type.
+ * @returns The query key for fetching the isPerson status.
+ */
+declare const getIsPersonQueryKey: (user: string, networkType: NETWORK_TYPE) => string[];
+/**
+ * Hook to get the isPerson status from the VeBetterPassport contract.
+ * @param user - The user address.
+ * @returns The isPerson status.
+ */
+declare const useIsPerson: (user?: string | null) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useMostVotedAppsInRound.d.ts
+type XApp = {
+  id: string;
+  teamWalletAddress: string;
+  name: string;
+  metadataURI: string;
+  createdAtTimestamp: string;
+};
+type MostVotedAppsInRoundReturnType = {
+  percentage: number;
+  id: string;
+  app: XApp;
+};
+/**
+ * Get the most voted apps in a round
+ *
+ * @param roundId the id of the round to get the most voted apps
+ * @returns a sorted array of the most voted apps in the round
+ */
+declare const useMostVotedAppsInRound: (roundId?: string) => {
+  data: MostVotedAppsInRoundReturnType[];
+  isLoading: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useRefreshBalances.d.ts
+declare const useRefreshBalances: () => {
+  refresh: () => Promise<void>;
+};
+//#endregion
+//#region src/hooks/api/wallet/useRefreshMetadata.d.ts
+declare const useRefreshMetadata: (domain: string, address: string) => {
+  refresh: () => Promise<void>;
+};
+//#endregion
+//#region src/hooks/api/wallet/useRoundXApps.d.ts
+declare const getRoundXAppsQueryKey: (roundId: string, networkType: NETWORK_TYPE) => (string | unknown[])[];
+declare const useRoundXApps: (roundId?: string) => _tanstack_react_query8.UseQueryResult<{
+  id: string;
+  teamWalletAddress: `0x${string}`;
+  name: string;
+  metadataURI: string;
+  createdAtTimestamp: string;
+}[], unknown>;
+//#endregion
+//#region src/hooks/api/wallet/useWallet.d.ts
+type UseWalletReturnType = {
+  account: Wallet;
+  connectedWallet: Wallet;
+  smartAccount: SmartAccount;
+  privyUser: User | null;
+  connection: {
+    isConnected: boolean;
+    isLoading: boolean;
+    isConnectedWithSocialLogin: boolean;
+    isConnectedWithDappKit: boolean;
+    isConnectedWithCrossApp: boolean;
+    isConnectedWithPrivy: boolean;
+    isConnectedWithVeChain: boolean;
+    source: ConnectionSource;
+    isInAppBrowser: boolean;
+    nodeUrl: string;
+    delegatorUrl?: string;
+    chainId?: string;
+    network: NETWORK_TYPE;
+  };
+  disconnect: () => Promise<void>;
+};
+declare const useWallet: () => UseWalletReturnType;
+//#endregion
+//#region src/hooks/api/wallet/useWalletMetadata.d.ts
+declare const useWalletMetadata: (address: string, networkType: NETWORK_TYPE) => {
+  domain: string | undefined;
+  image: string | undefined;
+  records: ENSRecords;
+  isLoading: boolean;
+};
+//#endregion
+//#region src/hooks/api/wallet/useXAppMetadata.d.ts
+/**
+ * The metadata of an xApp from the xApps metadata base uri
+ * @property name - The name of the xApp
+ * @property description - The description of the xApp
+ * @property distribution_strategy - The B3TR distribution strategy of the xApp
+ * @property external_url - The external url of the xApp
+ * @property logo - The logo of the xApp (ipfs uri)
+ * @property banner - The banner of the xApp (ipfs uri)
+ * @property screenshots - The screenshots of the xApp (ipfs uri)
+ * @property social_urls - The social urls of the xApp
+ * @property app_urls - The app urls of the xApp
+ * @property categories - The categories of the xApp
+ */
+type XAppMetadata = {
+  name: string;
+  description: string;
+  distribution_strategy?: string;
+  external_url: string;
+  logo: string;
+  banner: string;
+  screenshots: string[];
+  social_urls: {
+    name: string;
+    url: string;
+  }[];
+  app_urls: {
+    code: string;
+    url: string;
+  }[];
+  tweets: string[];
+  ve_world: {
+    banner: string;
+  };
+  categories: string[];
+};
+/**
+  dapp-kit broke the pre-fetching
+   * @param uri  - The uri of the xApps metadata
+   * @returns  The metadata of the xApp see {@link XAppMetadata}
+   */
+declare const getXAppMetadata: (uri: string, networkType: NETWORK_TYPE) => Promise<XAppMetadata | undefined>;
+declare const useXAppMetadata: (xAppId: string) => _tanstack_react_query8.UseQueryResult<XAppMetadata | undefined, Error>;
+//#endregion
+//#region src/hooks/api/wallet/useXAppShares.d.ts
+/**
+ *  Returns the query key for the shares of multiple xApps in an allocation round.
+ * @param roundId  the roundId the get the shares for
+ */
+declare const getXAppsSharesQueryKey: (roundId?: number | string) => (string | number | undefined)[];
+/**
+ * Fetch shares of multiple xApps in an allocation round
+ * @param apps  the xApps to get the shares for
+ * @param roundId  the round id to get the shares for
+ * @returns  the shares (% of allocation pool) for the xApps in the round { allocated: number, unallocated: number }
+ *
+ */
+declare const useXAppsShares: (apps: string[], roundId?: string) => _tanstack_react_query8.UseQueryResult<{
+  app: string;
+  share: number;
+  unallocatedShare: number;
+}[], Error>;
+//#endregion
+//#region src/hooks/api/ipfs/useIpfsMetadata.d.ts
+/**
+ * Fetches metadata from IPFS for a given URI
+ *
+ * @param networkType - The network type
+ * @param uri - The IPFS URI
+ * @param parseJson - Whether to parse the JSON
+ * @returns The metadata
+ */
+declare const getIpfsMetadata: <T$1>(networkType: NETWORK_TYPE, uri?: string, parseJson?: boolean) => Promise<T$1>;
+declare const getIpfsMetadataQueryKey: (networkType: NETWORK_TYPE, ipfsUri?: string) => (string | undefined)[];
+/**
+ * Fetches metadata from IPFS for a given URI
+ * @param ipfsUri - The IPFS URI
+ * @returns The metadata from IPFS
+ */
+declare const useIpfsMetadata: <T$1>(ipfsUri?: string, parseJson?: boolean) => _tanstack_react_query8.UseQueryResult<_tanstack_react_query8.NoInfer<T$1>, Error>;
+//#endregion
+//#region src/hooks/api/ipfs/useIpfsImage.d.ts
+interface IpfsImage {
+  image: string;
+  mime: string;
+  mediaType: NFTMediaType;
+}
+declare const MAX_IMAGE_SIZE: number;
+/**
+ * Fetches NFT media from IPFS
+ * @param networkType - The network type
+ * @param uri - The IPFS URI of the NFT media
+ * @returns The NFT media
+ */
+declare const getIpfsImage: (networkType: NETWORK_TYPE, uri?: string) => Promise<IpfsImage>;
+/**
+ * @param networkType - The network type
+ * @param imageIpfsUri - The IPFS URI of the NFT media
+ * @returns The NFT media
+ */
+declare const getIpfsImageQueryKey: (networkType: NETWORK_TYPE, imageIpfsUri?: null | string) => (string | null | undefined)[];
+/**
+ * Hook to fetch NFT media from IPFS
+ * @param imageIpfsUri - The IPFS URI of the NFT media
+ * @returns The NFT media
+ */
+declare const useIpfsImage: (imageIpfsUri?: null | string) => _tanstack_react_query8.UseQueryResult<IpfsImage, Error>;
+/**
+ * Custom hook to fetch a list of IPFS images.
+ *
+ * @param imageIpfsUriList - An array of IPFS URIs for the images.
+ * @returns An array of queries for each IPFS image URI.
+ */
+declare const useIpfsImageList: (imageIpfsUriList: string[]) => _tanstack_react_query8.UseQueryResult<IpfsImage, Error>[];
+//#endregion
+//#region src/hooks/api/ipfs/useIpfsMetadatas.d.ts
+/**
+ * Fetches metadatas from IPFS for given URIs
+ * @param ipfsUris - The IPFS URIs
+ * @returns The metadata from IPFS for each URI
+ */
+declare const useIpfsMetadatas: <T$1>(ipfsUris: string[], parseJson?: boolean) => _tanstack_react_query8.UseQueryResult<T$1, Error>[];
+//#endregion
+//#region src/hooks/api/ipfs/useUploadImages.d.ts
+declare const imageCompressionOptions: Options;
+declare const compressImages: (images: UploadedImage[]) => Promise<File[]>;
+type Props$20 = {
+  compressImages?: boolean;
+  defaultImages?: UploadedImage[];
+};
+/**
+ *  Hook to handle image uploads and compressions in a dropzone
+ * @param param0  compressImages: boolean to indicate if the images should be compressed (default: true)
+ * @returns  uploadedImages: array of uploaded images, setUploadedImages: function to set the uploaded images, onDrop: function to handle the drop event
+ */
+type UploadedImage = {
+  file: File;
+  image: string;
+};
+declare const useUploadImages: ({
+  compressImages,
+  defaultImages
+}: Props$20) => {
+  uploadedImages: UploadedImage[];
+  setUploadedImages: react0.Dispatch<react0.SetStateAction<UploadedImage[]>>;
+  onUpload: (acceptedFiles: File[], keepCurrent?: boolean) => Promise<void>;
+  onRemove: (index: number) => void;
+  invalidDateError: number[];
+};
+//#endregion
+//#region src/hooks/api/ipfs/useSingleImageUpload.d.ts
+type Props$19 = {
+  compressImage?: boolean;
+  defaultImage?: UploadedImage;
+};
+/**
+ *  Hook to handle image uploads and compressions in a dropzone
+ * @param param0  compressImags: boolean to indicate if the image should be compressed (default: true)
+ * @param param1  defaultImage: default image to be displayed
+ * @returns   uploaded image, setUploadedImage: function to set the uploaded image, onDrop: function to handle the drop event
+ */
+declare const useSingleImageUpload: ({
+  compressImage,
+  defaultImage
+}: Props$19) => {
+  uploadedImage: UploadedImage | undefined;
+  setUploadedImage: react0.Dispatch<react0.SetStateAction<UploadedImage | undefined>>;
+  onUpload: (acceptedFile: File) => Promise<UploadedImage>;
+  onRemove: () => void;
+};
+//#endregion
+//#region src/types/swap.d.ts
+/**
+ * Swap quote from an aggregator
+ */
+interface SwapQuote {
+  /**
+   * The aggregator name (e.g., "BetterSwap", "VeTrade")
+   */
+  aggregatorName: string;
+  /**
+   * Reference to the aggregator that generated this quote
+   */
+  aggregator: SwapAggregator;
+  /**
+   * Amount of output token to receive
+   */
+  outputAmount: bigint;
+  /**
+   * Estimated price impact percentage
+   */
+  priceImpact?: number;
+  /**
+   * Minimum amount of output token (considering slippage)
+   */
+  minimumOutputAmount?: bigint;
+  /**
+   * Additional data needed for transaction building
+   */
+  data?: unknown;
+  /**
+   * Whether the transaction simulation reverted
+   */
+  reverted?: boolean;
+  /**
+   * Revert reason if simulation failed
+   */
+  revertReason?: string;
+  /**
+   * Estimated gas cost in VTHO (from simulation)
+   */
+  gasCostVTHO?: number;
+}
+/**
+ * Swap simulation result
+ */
+interface SwapSimulation {
+  /**
+   * Estimated gas cost in VTHO
+   */
+  gasCostVTHO: number;
+  /**
+   * Whether the simulation was successful
+   */
+  success: boolean;
+  /**
+   * Error message if simulation failed
+   */
+  error?: string;
+}
+/**
+ * Swap parameters
+ */
+interface SwapParams {
+  /**
+   * Address of the token to swap from
+   */
+  fromTokenAddress: string;
+  /**
+   * Address of the token to swap to
+   */
+  toTokenAddress: string;
+  /**
+   * Amount of input token (in raw format, e.g., Wei)
+   */
+  amountIn: string;
+  /**
+   * Address of the user making the swap
+   */
+  userAddress: string;
+  /**
+   * Slippage tolerance percentage (default: 1)
+   */
+  slippageTolerance?: number;
+}
+/**
+ * Aggregator module interface
+ * Each aggregator must implement these functions
+ */
+interface SwapAggregator {
+  /**
+   * Get a swap quote
+   * @param params Swap parameters
+   * @param thor Thor client instance for contract calls
+   * @returns Promise resolving to a swap quote
+   */
+  getQuote(params: SwapParams, thor: ThorClient): Promise<SwapQuote>;
+  /**
+   * Simulate the swap transaction to estimate gas
+   * @param params Swap parameters
+   * @param quote The quote from getQuote
+   * @param thor Thor client instance for transaction simulation
+   * @returns Promise resolving to simulation result
+   */
+  simulateSwap(params: SwapParams, quote: SwapQuote, thor: ThorClient): Promise<SwapSimulation>;
+  /**
+   * Build transaction clauses for the swap
+   * @param params Swap parameters
+   * @param quote The quote from getQuote
+   * @returns Promise resolving to transaction clauses
+   */
+  buildSwapTransaction(params: SwapParams, quote: SwapQuote): Promise<TransactionClause[]>;
+  /**
+   * Display name of the aggregator
+   */
+  name: string;
+  /**
+   * Icon component for the aggregator
+   * @param boxSize Size of the icon (e.g., "20px", "24px")
+   * @returns React element representing the aggregator icon
+   */
+  getIcon: (boxSize?: string) => React$1.ReactElement;
+}
+//#endregion
+//#region src/hooks/api/swap/useSwapTransaction.d.ts
+/**
+ * Hook to execute a swap transaction
+ */
+declare const useSwapTransaction: (params: SwapParams | null, quote: SwapQuote | null) => {
+  executeSwap: () => Promise<void>;
+  isTransactionPending: boolean;
+  isWaitingForWalletConfirmation: boolean;
+  txReceipt: _vechain_sdk_network0.TransactionReceipt | null;
+  status: TransactionStatus;
+  resetStatus: () => void;
+  error: TransactionStatusErrorType | undefined;
+};
+//#endregion
+//#region src/hooks/api/swap/useSwapQuotes.d.ts
+type UnifiedSwapQuotesResult = {
+  bestQuote: SwapQuote | null;
+  quotes: SwapQuote[];
+  isLoading: boolean;
+  error: unknown;
+  from: TokenWithValue & {
+    address: string;
+    decimals: number;
+  } | null;
+  to: TokenWithValue & {
+    address: string;
+    decimals: number;
+  } | null;
+};
+/**
+ * Unified hook: fetches quotes from all aggregators, simulates each, returns
+ * - bestQuote (filtered against reverts when at least one succeeds)
+ * - quotes: full list with revert flags and gas
+ */
+declare const useSwapQuotes: (fromToken: TokenWithValue | null, toToken: TokenWithValue | null, amountIn: string, userAddress: string, slippageTolerance?: number, enabled?: boolean) => UnifiedSwapQuotesResult;
+//#endregion
+//#region src/hooks/modals/useConnectModal.d.ts
+declare const useConnectModal: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const ConnectModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useAccountModal.d.ts
+declare const useAccountModal: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const AccountModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useTransactionModal.d.ts
+declare const useTransactionModal: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const TransactionModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useTransactionToast.d.ts
+declare const useTransactionToast: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const TransactionToastProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useWalletModal.d.ts
+declare const useWalletModal: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const WalletModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useChooseNameModal.d.ts
+declare const useChooseNameModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const ChooseNameModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useSendTokenModal.d.ts
+declare const useSendTokenModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const SendTokenModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useSwapTokenModal.d.ts
+type SwapTokenModalOptions = {
+  fromTokenAddress?: string;
+  toTokenAddress?: string;
+  isolatedView?: boolean;
+};
+declare const useSwapTokenModal: () => {
+  open: (options?: SwapTokenModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const SwapTokenModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useAccessAndSecurityModal.d.ts
+declare const useAccessAndSecurityModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const AccessAndSecurityModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useExploreEcosystemModal.d.ts
+declare const useExploreEcosystemModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const ExploreEcosystemModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useNotificationsModal.d.ts
+declare const useNotificationsModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const NotificationsModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useFAQModal.d.ts
+declare const useFAQModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const FAQModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useAccountCustomizationModal.d.ts
+declare const useAccountCustomizationModal: () => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const AccountCustomizationModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useReceiveModal.d.ts
+declare const useReceiveModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const ReceiveModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useLoginModalContent.d.ts
+type LoginModalContentConfig = {
+  showGoogleLogin: boolean;
+  showEmailLogin: boolean;
+  showPasskey: boolean;
+  showVeChainLogin: boolean;
+  showDappKit: boolean;
+  showEcosystem: boolean;
+  showMoreLogin: boolean;
+  showGithubLogin: boolean;
+  isOfficialVeChainApp: boolean;
+};
+declare const useLoginModalContent: () => LoginModalContentConfig;
+//#endregion
+//#region src/hooks/modals/useUpgradeSmartAccountModal.d.ts
+declare const useUpgradeSmartAccountModal: (style?: UpgradeSmartAccountModalStyle) => {
+  open: () => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const UpgradeSmartAccountModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useProfileModal.d.ts
+declare const useProfileModal: () => {
+  open: (options?: AccountModalOptions) => void;
+  close: () => void;
+  isOpen: boolean;
+};
+declare const ProfileModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/modals/useAccountModalOptions.d.ts
+declare const useAccountModalOptions: () => {
+  isolatedView: boolean;
+  closeAccountModal: () => void;
+};
+//#endregion
+//#region src/hooks/notifications/types.d.ts
+type NotificationAction = {
+  label: string;
+  content: AccountModalContentTypes;
+};
+type Notification = {
+  id: string;
+  title: string;
+  description: string;
+  timestamp: number;
+  status: 'success' | 'info' | 'warning' | 'error';
+  isRead: boolean;
+  action?: NotificationAction;
+};
+//#endregion
+//#region src/hooks/notifications/useNotifications.d.ts
+declare const useNotifications: () => {
+  getNotifications: () => Notification[];
+  getArchivedNotifications: () => Notification[];
+  addNotification: (notification: Omit<Notification, "timestamp" | "isRead">) => void;
+  clearAllNotifications: () => void;
+  markAsRead: (notificationId: string) => void;
+  deleteNotification: (notificationId: string) => void;
+};
+//#endregion
+//#region src/hooks/notifications/useNotificationAlerts.d.ts
+declare const useNotificationAlerts: () => void;
+//#endregion
+//#region src/hooks/signing/useSignMessage.d.ts
+type UseSignMessageReturnValue = {
+  signMessage: (message: string) => Promise<string>;
+  isSigningPending: boolean;
+  signature: string | null;
+  error: Error | null;
+  reset: () => void;
+};
+/**
+ * Hook to sign messages using the connected wallet.
+ * Supports both Privy and VeChain wallets.
+ *
+ * @returns {UseSignMessageReturnValue} Object containing the signing function and status
+ */
+declare const useSignMessage: () => UseSignMessageReturnValue;
+//#endregion
+//#region src/hooks/signing/useSignTypedData.d.ts
+type UseSignTypedDataReturnValue = {
+  signTypedData: (data: SignTypedDataParams, options?: {
+    signer?: string;
+  }) => Promise<string>;
+  isSigningPending: boolean;
+  signature: string | null;
+  error: Error | null;
+  reset: () => void;
+};
+/**
+ * Hook to sign typed data using the connected wallet.
+ * Supports both Privy and VeChain wallets.
+ *
+ * @returns {UseSignTypedDataReturnValue} Object containing the signing function and status
+ */
+declare const useSignTypedData: () => UseSignTypedDataReturnValue;
+//#endregion
+//#region src/hooks/login/useLoginWithPasskey.d.ts
+declare const useLoginWithPasskey: () => {
+  loginWithPasskey: () => Promise<void>;
+};
+//#endregion
+//#region src/hooks/login/useLoginWithOAuth.d.ts
+interface OAuthOptions {
+  provider: OAuthProviderType;
+}
+declare const useLoginWithOAuth: () => {
+  initOAuth: ({
+    provider
+  }: OAuthOptions) => Promise<void>;
+};
+//#endregion
+//#region src/hooks/login/useLoginWithVeChain.d.ts
+declare const useLoginWithVeChain: () => {
+  login: () => Promise<void>;
+};
+//#endregion
+//#region src/components/AccountModal/Contents/Ecosystem/Components/CategoryLabel.d.ts
+type AllowedCategories = 'defi' | 'games' | 'collectibles' | 'marketplaces' | 'utilities' | 'vebetter';
+//#endregion
+//#region src/hooks/utils/useAppHubApps.d.ts
+type AppHubApp = {
+  id: string;
+  name: string;
+  description: string;
+  url: string;
+  logo: string;
+  category: AllowedCategories;
+  tags: string[];
+  isVeWorldSupported: boolean;
+  repo?: string;
+  contracts?: string[];
+  veBetterDaoId?: string;
+};
+/**
+ * Query key for AppHub apps
+ */
+declare const getAppHubAppsQueryKey: () => string[];
+/**
+ * Fetches apps from the VeChain App Hub repository
+ * @returns A list of apps from the VeChain App Hub
+ */
+declare const fetchAppHubApps: () => Promise<AppHubApp[]>;
+/**
+ * Hook to fetch apps from the VeChain App Hub repository
+ * @returns The query result containing apps from the VeChain App Hub
+ *
+ * @example
+ * ```tsx
+ * const { data: apps, isLoading, error } = useAppHubApps();
+ *
+ * if (isLoading) return <div>Loading...</div>;
+ * if (error) return <div>Error loading apps</div>;
+ *
+ * return (
+ *   <div>
+ *     {apps?.map(app => (
+ *       <AppCard key={app.id} app={app} />
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+declare const useAppHubApps: () => _tanstack_react_query8.UseQueryResult<AppHubApp[], Error>;
+//#endregion
+//#region src/utils/constants.d.ts
+declare const TOKEN_LOGOS: Record<string, string>;
+declare const TOKEN_LOGO_COMPONENTS: Record<string, JSX.Element>;
+declare const VECHAIN_PRIVY_APP_ID = "cm4wxxujb022fyujl7g0thb21";
+declare const notFoundImage = "https://upload.wikimedia.org/wikipedia/commons/a/a3/Image-not-found.png";
+declare enum TogglePassportCheck {
+  WhitelistCheck = 1,
+  BlacklistCheck = 2,
+  SignalingCheck = 3,
+  ParticipationScoreCheck = 4,
+  GmOwnershipCheck = 5,
+}
+declare const VECHAIN_KIT_STORAGE_KEYS: {
+  NETWORK: string;
+};
+declare const getENV: () => {
+  isDevelopment: boolean;
+  isProduction: boolean;
+};
+declare const ENV: {
+  readonly isDevelopment: boolean;
+  readonly isProduction: boolean;
+};
+declare const getGenericDelegatorUrl: () => "https://mainnet.delegator.vechain.org/api/v1/" | "https://testnet.delegator.vechain.org/api/v1/";
+type PrivyEcosystemApp = {
+  id: string;
+  name: string;
+  website: string;
+};
+declare const DEFAULT_PRIVY_ECOSYSTEM_APPS: PrivyEcosystemApp[];
+declare const VECHAIN_KIT_TERMS_CONFIG: {
+  url: string;
+  version: number;
+  required: boolean;
+  displayName: string;
+};
+declare const VECHAIN_KIT_COOKIES_CONFIG: {
+  url: string;
+  version: number;
+  required: boolean;
+  displayName: string;
+};
+declare const DEFAULT_GAS_TOKEN_PREFERENCES: GasTokenPreferences;
+declare const SUPPORTED_GAS_TOKENS: Record<GasTokenType, GasTokenInfo>;
+//#endregion
+//#region src/utils/formattingUtils.d.ts
+declare const humanAddress: (address: string, charAtStart?: number, charAtEnd?: number) => string;
+declare const humanDomain: (domain: string, lengthBefore?: number, lengthAfter?: number) => string;
+declare const humanNumber: (formattedValue: BigNumber.Value, originalValue?: BigNumber.Value, symbol?: string | null) => string;
+declare const isZero: (value?: BigNumber.Value) => boolean;
+declare const getPicassoImage: (address: string, base64?: boolean) => string;
+/**
+ * Format the token balance human friendly
+ * @param balance - balance in bigint
+ * @returns the formatted balance in the form of {@link TokenBalance} (original, scaled down and formatted)
+ */
+declare const formatTokenBalance: (balance: bigint) => {
+  original: string;
+  scaled: string;
+  formatted: string;
+};
+//#endregion
+//#region src/utils/randomTxForwarder.d.ts
+declare const randomTransactionUser: {
+  privateKey: string;
+  account: Account;
+  address: string;
+};
+//#endregion
+//#region src/utils/addressUtils.d.ts
+/**
+ * Checks if two addresses are equal. Returns true if both values are strings AND:
+ *  - The two values are equal OR
+ *  - The checksumed addresses are equal
+ *
+ * @param address1
+ * @param address2
+ */
+declare const compareAddresses: (address1?: string, address2?: string) => boolean;
+declare const compareListOfAddresses: (add1: string[], add2: string[]) => boolean;
+declare const regexPattern: () => RegExp;
+declare const isValidAddress: typeof Address.isValid;
+declare const leftPadWithZeros: (str: string, length: number) => string;
+//#endregion
+//#region src/utils/ipfs.d.ts
+/**
+ * Validate IPFS URI strings. An example of a valid IPFS URI is:
+ * - ipfs://QmfSTia1TJUiKQ2fyW9NTPzEKNdjMGzbUgrC3QPSTpkum6/406.json
+ * - ipfs://QmVPqKfwRXjg5Fqwy6RNRbKR2ZP4pKKVLvmfjmhQfdM3MH/4
+ * - ipfs://QmVPqKfwRXjg5Fqwy6RNRbKR2ZP4pKKVLvmfjmhQfdM3MH
+ * @param uri
+ * @returns
+ */
+declare const validateIpfsUri: (uri: string) => boolean;
+/**
+ * Converts a CID to an IPFS native URL.
+ *
+ * @param cid - The CID to convert.
+ * @param fileName - The name of the file to append to the URL.
+ *
+ * @returns The IPFS URL in the format `ipfs://${cid}/${fileName}`.
+ */
+declare function toIPFSURL(cid: string, fileName?: string): string;
+/**
+ * Uploads a blob to IPFS.
+ * @param blob The Blob object to upload.
+ * @param filename A name for the file in the FormData payload.
+ * @param networkType The network type to use for the IPFS pinning service.
+ * @returns The IPFS hash of the uploaded blob.
+ */
+declare function uploadBlobToIPFS(blob: Blob, filename: string, networkType: NETWORK_TYPE): Promise<string>;
+//#endregion
+//#region src/utils/media.d.ts
+declare const resolveMediaTypeFromMimeType: (mimeType: string) => NFTMediaType;
+//#endregion
+//#region src/utils/uri.d.ts
+/**
+ * Convert a URI to a URL
+ * We support both IPFS and Arweave URIs. Both should be converted to their https gateway URLs.
+ * All other URIs should pass through unchanged.
+ *
+ * @param uri
+ */
+declare const convertUriToUrl: (uri: string, networkType: NETWORK_TYPE) => string | null;
+//#endregion
+//#region src/utils/gmNfts.d.ts
+declare const gmNfts: {
+  level: string;
+  name: string;
+  image: string;
+  multiplier: number;
+  b3trToUpgrade: number;
+}[];
+/**
+ * Maps the XNode level to the GM starting level.
+ */
+declare const xNodeToGMstartingLevel: Record<number, number>;
+//#endregion
+//#region src/utils/buildQueryString.d.ts
+declare const buildQueryString: (params: {
+  [key: string]: any;
+}) => string;
+//#endregion
+//#region src/utils/xNode.d.ts
+/**
+ * Map strength level coming from contract to hq image
+ */
+declare const NodeStrengthLevelToImage: {
+  [key: string]: string;
+};
+declare const MinXNodeLevel = 4;
+declare const EconomicNodeStrengthLevelToName: {
+  [key: string]: string;
+};
+declare const XNodeStrengthLevelToName: {
+  [key: string]: string;
+};
+declare const allNodeStrengthLevelToName: {
+  [key: string]: string;
+};
+//#endregion
+//#region src/utils/time.d.ts
+declare const TIME: {
+  SECOND: number;
+  MINUTE: number;
+  HOUR: number;
+  DAY: number;
+  WEEK: number;
+  MONTH: number;
+  YEAR: number;
+};
+//#endregion
+//#region src/utils/stringUtils.d.ts
+/**
+ * Checks if a string contains common rejection-related terms
+ * @param errorMessage The error message to check
+ * @returns boolean indicating if the message contains rejection terms
+ */
+declare const isRejectionError: (errorMessage: string) => boolean;
+//#endregion
+//#region src/utils/hexUtils.d.ts
+/**
+ * Returns the provied hex string with the hex prefix removed.
+ * If the prefix doesn't exist the hex is returned unmodified
+ * @param hex - the input hex string
+ * @returns the input hex string with the hex prefix removed
+ * @throws an error if the input is not a valid hex string
+ */
+declare const removePrefix: (hex: string) => string;
+/**
+ * Returns the provided hex string with the hex prefix added.
+ * If the prefix already exists the string is returned unmodified.
+ * If the string contains an UPPER case `X` in the prefix it will be replaced with a lower case `x`
+ * @param hex - the input hex string
+ * @returns the input hex string with the hex prefix added
+ * @throws an error if the input is not a valid hex string
+ */
+declare const addPrefix: (hex: string) => string;
+/**
+ * Validate the hex string. Throws an Error if not valid
+ * @param hex - the input hex string
+ * @throws an error if the input is not a valid hex string
+ */
+declare const validate: (hex: string) => void;
+/**
+ * Check if input string is valid
+ * @param hex - the input hex string
+ * @returns boolean representing whether the input hex is valid
+ */
+declare const isValid: (hex?: string | null) => boolean;
+declare const isInvalid: (hex?: string | null) => boolean;
+declare const normalize: (hex: string) => string;
+declare const compare: (hex1: string, hex2: string) => boolean;
+//#endregion
+//#region src/utils/url.d.ts
+declare const isValidUrl: (value: string) => boolean;
+//#endregion
+//#region src/utils/thorUtils.d.ts
+type ExtractViewFunction$1<TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, 'pure' | 'view'>> = Extract<TAbi[number], {
+  type: 'function';
+  stateMutability: 'pure' | 'view';
+  name: TMethod;
+}>;
+type ViewFunctionResult<TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, 'pure' | 'view'>> = AbiParametersToPrimitiveTypes<ExtractViewFunction$1<TAbi, TMethod>['outputs'], 'outputs'>;
+type MultipleClausesCallParameters<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true> = MulticallParameters<contracts, allowFailure>['contracts'];
+type MultipleClausesCallReturnType<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true> = MulticallReturnType<contracts, allowFailure>;
+declare const executeCallClause: <TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, "pure" | "view">>({
+  thor,
+  contractAddress,
+  abi,
+  method,
+  args
+}: {
+  thor: ThorClient;
+  contractAddress: string;
+  abi: TAbi;
+  method: TMethod;
+  args: AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TMethod>["inputs"], "inputs">;
+}) => Promise<(Extract<TAbi[number], {
+  type: "function";
+  stateMutability: "pure" | "view";
+  name: TMethod;
+}>["outputs"] extends infer T_1 extends readonly abitype0.AbiParameter[] ? { [key_1 in keyof T_1]: abitype0.AbiParameterToPrimitiveType<T_1[key_1], abiParameterKind> } : never) extends infer T ? { [key in keyof T]: T[key] } : never>;
+declare const executeMultipleClausesCall: <contracts extends readonly ContractFunctionParameters[], allowFailure extends boolean = false>({
+  thor,
+  calls
+}: {
+  thor: ThorClient;
+  calls: MultipleClausesCallParameters<contracts, allowFailure>;
+}) => Promise<MultipleClausesCallReturnType<contracts, allowFailure>>;
+declare const buildCallClauses: <contracts extends readonly ContractFunctionParameters[], allowFailure extends boolean = false>({
+  thor,
+  calls
+}: {
+  thor: ThorClient;
+  calls: MultipleClausesCallParameters<contracts, allowFailure>;
+}) => _vechain_sdk_core0.ContractClause[];
+//#endregion
+//#region src/utils/ssrUtils.d.ts
+/**
+ * SSR-safe utilities for browser API access
+ */
+/**
+ * SSR-safe localStorage getter
+ */
+declare const getLocalStorageItem: (key: string) => string | null;
+/**
+ * SSR-safe localStorage setter
+ */
+declare const setLocalStorageItem: (key: string, value: string) => void;
+/**
+ * SSR-safe localStorage remover
+ */
+declare const removeLocalStorageItem: (key: string) => void;
+/**
+ * SSR-safe document.title getter
+ */
+declare const getDocumentTitle: () => string;
+/**
+ * SSR-safe window.location.origin getter
+ */
+declare const getWindowOrigin: () => string;
+/**
+ * Check if we're in a browser environment
+ */
+declare const isBrowser: () => boolean;
+/**
+ * SSR-safe window.open
+ */
+declare const safeWindowOpen: (url?: string, target?: string, features?: string) => void;
+/**
+ * SSR-safe document.querySelector
+ */
+declare const safeQuerySelector: <T$1 extends Element>(selector: string) => T$1 | null;
+/**
+ * SSR-safe navigator check
+ */
+declare const hasNavigator: () => boolean;
+/**
+ * SSR-safe navigator.onLine check
+ */
+declare const isOnline: () => boolean;
+/**
+ * SSR-safe clipboard write
+ */
+declare const copyToClipboard: (text: string) => Promise<boolean>;
+//#endregion
+//#region src/hooks/utils/useCallClause.d.ts
+type ExtractViewFunction<TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, 'pure' | 'view'>> = Extract<TAbi[number], {
+  type: 'function';
+  stateMutability: 'pure' | 'view';
+  name: TMethod;
+}>;
+declare const getCallClauseQueryKey: <TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, "pure" | "view">>({
+  abi,
+  address,
+  method
+}: {
+  abi: TAbi;
+  address: string;
+  method: TMethod;
+}) => string[];
+declare const getCallClauseQueryKeyWithArgs: <TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, "pure" | "view">>({
+  abi,
+  address,
+  method,
+  args
+}: {
+  abi: TAbi;
+  address: string;
+  method: TMethod;
+  args?: AbiParametersToPrimitiveTypes<ExtractViewFunction<TAbi, TMethod>["inputs"], "inputs">;
+}) => (string | unknown[])[];
+declare const useCallClause: <TAbi extends Abi, TMethod extends ExtractAbiFunctionNames<TAbi, "pure" | "view">, TData = ViewFunctionResult<TAbi, TMethod>>({
+  address,
+  abi,
+  method,
+  args,
+  queryOptions
+}: {
+  address: string;
+  abi: TAbi;
+  method: TMethod;
+  args: AbiParametersToPrimitiveTypes<ExtractViewFunction<TAbi, TMethod>["inputs"], "inputs">;
+  queryOptions?: Omit<UseQueryOptions<ViewFunctionResult<TAbi, TMethod>, unknown, TData, ReturnType<typeof getCallClauseQueryKeyWithArgs<TAbi, TMethod>>>, "queryKey" | "queryFn">;
+}) => _tanstack_react_query8.UseQueryResult<_tanstack_react_query8.NoInfer<TData>, unknown>;
+declare const useMultipleClausesCall: <contracts extends readonly ContractFunctionParameters[], allowFailure extends boolean = false>({
+  thor,
+  calls,
+  queryKey,
+  enabled
+}: {
+  thor: ThorClient;
+  calls: MultipleClausesCallParameters<contracts, allowFailure>;
+  queryKey: string[];
+  enabled?: boolean;
+}) => _tanstack_react_query8.UseQueryResult<_tanstack_react_query8.NoInfer<MultipleClausesCallReturnType<contracts, false>>, Error>;
+//#endregion
+//#region src/hooks/utils/useCurrency.d.ts
+/**
+ * Hook for managing currency preferences
+ */
+declare const useCurrency: () => {
+  currentCurrency: CURRENCY;
+  allCurrencies: CURRENCY[];
+  changeCurrency: (newCurrency: CURRENCY) => void;
+};
+//#endregion
+//#region src/hooks/utils/useFeatureAnnouncement.d.ts
+declare const useFeatureAnnouncement: () => {
+  isVisible: boolean;
+  closeAnnouncement: () => void;
+};
+//#endregion
+//#region src/hooks/utils/useGetNodeUrl.d.ts
+declare const useGetNodeUrl: () => string;
+//#endregion
+//#region src/hooks/utils/useIsPwa.d.ts
+declare const useIsPWA: () => boolean;
+//#endregion
+//#region src/hooks/utils/useScrollToTop.d.ts
+declare const useScrollToTop: () => void;
+//#endregion
+//#region src/hooks/utils/useEvents.d.ts
+declare const decodeEventLog$1: <TAbi extends Abi>(event: EventLogs, abi: TAbi) => {
+  meta: EventLogs["meta"];
+  decodedData: ReturnType<typeof decodeEventLog<TAbi>>;
+};
+type UseEventsParams<T$1 extends Abi, K extends ContractEventName<T$1>, R> = {
+  abi: T$1;
+  contractAddress: string;
+  eventName: K;
+  filterParams?: Record<string, unknown> | unknown[] | undefined;
+  mapResponse: ({
+    meta,
+    decodedData
+  }: {
+    meta: EventLogs['meta'];
+    decodedData: ReturnType<typeof decodeEventLog<T$1, K>>;
+  }) => R;
+  nodeUrl: string;
+};
+type GetEventsKeyParams = {
+  eventName: string;
+  filterParams?: object;
+};
+declare const getEventsKey: ({
+  eventName,
+  filterParams
+}: GetEventsKeyParams) => string[];
+/**
+ * Custom hook for fetching contract events.
+ */
+declare const useEvents: <T$1 extends Abi, K extends ContractEventName<T$1>, R>({
+  abi,
+  contractAddress,
+  eventName,
+  filterParams,
+  mapResponse,
+  nodeUrl
+}: UseEventsParams<T$1, K, R>) => _tanstack_react_query8.UseQueryResult<R[], Error>;
+//#endregion
+//#region src/hooks/utils/useBuildClauses.d.ts
+interface BuildClausesParams {
+  clauses: EnhancedClause[];
+  smartAccount: SmartAccountReturnType;
+  version: number | undefined;
+  title?: string;
+  description?: string;
+  buttonText?: string;
+}
+/**
+ * Build the typed data structure for executeBatchWithAuthorization
+ * @param clauses - The clauses to sign
+ * @param chainId - The chain id
+ * @param verifyingContract - The address of the smart account
+ * @returns The typed data structure for executeBatchWithAuthorization
+ */
+declare function buildBatchAuthorizationTypedData({
+  clauses,
+  chainId,
+  verifyingContract
+}: {
+  clauses: TransactionClause[];
+  chainId: number;
+  verifyingContract: string;
+}): ExecuteBatchWithAuthorizationSignData;
+/**
+ * Build the typed data structure for executeWithAuthorization
+ * @param clause - The clause to sign
+ * @param chainId - The chain id
+ * @param smartAccount - The smart account object
+ * @returns The typed data structure for executeWithAuthorization
+ */
+declare function buildSingleAuthorizationTypedData({
+  clause,
+  chainId,
+  smartAccount
+}: {
+  clause: TransactionClause;
+  chainId: number;
+  smartAccount: SmartAccountReturnType;
+}): ExecuteWithAuthorizationSignData;
+/**
+ * Build either executeWithAuthorization or executeBatchWithAuthorization clauses based on smart account version using buildClausesWithAuth
+ * @param clauses - Either VET or ERC20 clauses
+ * @param smartAccount - The user's smart account object
+ * @param version - The smart account version
+ * @param title - The title of the transaction
+ * @param description - The description of the transaction
+ * @param buttonText - The button text of the transaction
+ * @returns The clauses for the executeWithAuthorization or executeBatchWithAuthorization function using buildClausesWithAuth
+ */
+declare const useBuildClauses: () => {
+  buildClausesWithAuth: (params: BuildClausesParams) => Promise<Clause[]>;
+};
+//#endregion
+//#region src/hooks/cache/useLocalStorage.d.ts
+declare enum LocalStorageKey {
+  CUSTOM_TOKENS = "vechain_kit_custom_tokens",
+  ECOSYSTEM_SHORTCUTS = "vechain-kit-ecosystem-shortcuts",
+  CURRENCY = "vechain_kit_currency",
+  NODE_URL = "vechain_kit_node_url",
+  NETWORK = "vechain_kit_network",
+  GAS_TOKEN_PREFERENCES = "vechain_kit_gas_token_preferences",
+}
+declare const useLocalStorage: <T$1>(key: LocalStorageKey, initialValue: T$1) => readonly [T$1, react0.Dispatch<react0.SetStateAction<T$1>>];
+//#endregion
+//#region src/hooks/cache/useSyncableLocalStorage.d.ts
+declare const useSyncableLocalStorage: <T$1>(key: string, defaultValue: T$1) => readonly [T$1, react0.Dispatch<react0.SetStateAction<T$1>>, () => void, () => T$1];
+//#endregion
+//#region src/hooks/cache/useEcosystemShortcuts.d.ts
+type EcosystemShortcut = {
+  name: string;
+  image: string;
+  url: string;
+  description?: string;
+};
+declare const useEcosystemShortcuts: () => {
+  shortcuts: EcosystemShortcut[];
+  addShortcut: (shortcut: EcosystemShortcut) => void;
+  removeShortcut: (url: string) => void;
+  isShortcut: (url: string) => boolean;
+};
+//#endregion
+//#region src/hooks/cache/useCrossAppConnectionCache.d.ts
+declare const useCrossAppConnectionCache: () => {
+  setConnectionCache: (ecosystemApp: {
+    name: string;
+    logoUrl?: string;
+    appId: string;
+    website?: string;
+  }) => void;
+  getConnectionCache: () => CrossAppConnectionCache | null;
+  clearConnectionCache: () => void;
+};
+//#endregion
+//#region src/hooks/generic-delegator/useGenericDelegator.d.ts
+declare const estimateGas: (signerAddress: string, genericDelegatorUrl: string, clauses: any[], token: GasTokenType, speed: TransactionSpeed) => Promise<any>;
+declare const getDepositAccount: (genericDelegatorUrl: string) => Promise<DepositAccount>;
+declare const delegateAuthorized: (encodedSignedTx: string, origin: string, token: GasTokenType, genericDelegatorUrl: string) => Promise<any>;
+declare const estimateAndBuildTxBody: (clauses: TransactionClause[], thor: ThorClient, randomTransactionUser: Wallet, isDelegated: boolean) => Promise<_vechain_sdk_core0.TransactionBody>;
+/**
+ * Sign the final transaction with the given private key and signature
+ * returned by the generic delegator.
+ * @param decodedTx The decoded transaction returned by the generic delegator.
+ * @param gasPayerSignature The signature returned by the generic delegator.
+ * @returns The signed final transaction.
+ */
+declare function signVip191Transaction(decodedTx: Transaction, gasPayerSignature: string): Transaction;
+declare function decodeRawTx(raw: any, isSigned: boolean): Transaction;
+/**
+ * This function is used to send a transaction using the generic delegator.
+ * It will build the necessary clauses, estimate the gas, and send the transaction.
+ * @param clauses The clauses to send in the transaction.
+ * @param genericDelegatorUrl The URL of the generic delegator.
+ * @returns
+ */
+declare const useGenericDelegator: () => {
+  sendTransactionUsingGenericDelegator: ({
+    clauses,
+    genericDelegatorUrl
+  }: {
+    clauses: TransactionClause[];
+    genericDelegatorUrl: string;
+  }) => Promise<string>;
+};
+//#endregion
+//#region src/hooks/generic-delegator/useGasTokenSelection.d.ts
+declare const useGasTokenSelection: () => {
+  preferences: GasTokenPreferences;
+  supportedTokens: Record<GasTokenType, GasTokenInfo>;
+  updatePreferences: (updates: Partial<GasTokenPreferences>) => void;
+  reorderTokenPriority: (newOrder: GasTokenType[]) => void;
+  toggleTokenExclusion: (token: GasTokenType) => void;
+};
+//#endregion
+//#region src/hooks/generic-delegator/useGasEstimation.d.ts
+interface UseGasEstimationParams {
+  clauses: EnhancedClause[];
+  enabled?: boolean;
+  tokens: string[];
+  sendingAmount?: string;
+  sendingTokenSymbol?: string;
+}
+declare const useGasEstimation: ({
+  clauses,
+  enabled,
+  tokens,
+  sendingAmount,
+  sendingTokenSymbol
+}: UseGasEstimationParams) => _tanstack_react_query8.UseQueryResult<EstimationResponse & {
+  usedToken: string;
+}, Error>;
+//#endregion
+//#region src/hooks/generic-delegator/useEstimateAllTokens.d.ts
+interface UseEstimateAllTokensParams {
+  clauses: TransactionClause[];
+  tokens: GasTokenType[];
+  enabled?: boolean;
+}
+declare const useEstimateAllTokens: ({
+  clauses,
+  tokens,
+  enabled
+}: UseEstimateAllTokensParams) => _tanstack_react_query8.UseQueryResult<Record<GasTokenType, {
+  cost: number;
+  loading: boolean;
+  error?: string;
+}>, Error>;
+//#endregion
+//#region src/hooks/thor/accounts/useAccountBalance.d.ts
+declare const getAccountBalance: (thor: ThorClient, address?: string) => Promise<{
+  balance: string;
+  energy: string;
+}>;
+declare const getAccountBalanceQueryKey: (address?: string) => (string | undefined)[];
+/**
+ *  Get the account balance for the given address
+ * @param address  The address of the account to get the balance for
+ * @returns  The account balance
+ */
+declare const useAccountBalance: (address?: string) => _tanstack_react_query8.UseQueryResult<{
+  balance: string;
+  energy: string;
+}, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useAccountImplementationAddress.d.ts
+declare const getAccountImplementationAddress: (thor: ThorClient, version?: number, networkType?: NETWORK_TYPE) => Promise<string>;
+declare const getAccountImplementationAddressQueryKey: (version?: number, networkType?: NETWORK_TYPE) => (string | number | undefined)[];
+/**
+ * Get the address of a smart account implementation for a given version
+ * @param version - The version of the smart account implementation
+ * @returns The address of the smart account implementation
+ */
+declare const useAccountImplementationAddress: (version?: number) => _tanstack_react_query8.UseQueryResult<string, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useCurrentAccountImplementationVersion.d.ts
+declare const getCurrentAccountImplementationVersion: (thor: ThorClient, networkType?: NETWORK_TYPE) => Promise<number>;
+declare const getCurrentAccountImplementationVersionQueryKey: (networkType?: NETWORK_TYPE) => (string | undefined)[];
+/**
+ * Get the current account implementation version used by the smart account factory
+ * @returns The current account implementation version
+ */
+declare const useCurrentAccountImplementationVersion: () => _tanstack_react_query8.UseQueryResult<number, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useGetAccountAddress.d.ts
+declare const getAccountAddress: (thor: ThorClient, ownerAddress?: string, networkType?: NETWORK_TYPE) => Promise<string>;
+declare const getAccountAddressQueryKey: (ownerAddress?: string, networkType?: NETWORK_TYPE) => (string | undefined)[];
+/**
+ * Get the address of a smart account
+ * @param ownerAddress - The address of the owner of the smart account
+ * @returns The address of the smart account
+ */
+declare const useGetAccountAddress: (ownerAddress?: string) => _tanstack_react_query8.UseQueryResult<string, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useGetAccountVersion.d.ts
+declare const getAccountVersionQueryKey: (accountAddress: string, ownerAddress: string, networkType: NETWORK_TYPE) => (string | unknown[])[];
+/**
+ * Check if a smart account has a v1 smart account
+ * @param accountAddress - The address of the smart account
+ * @param ownerAddress - The address of the owner of the smart account
+ * @returns The version of the smart account
+ */
+declare const useGetAccountVersion: (accountAddress: string, ownerAddress: string) => _tanstack_react_query8.UseQueryResult<{
+  version: number;
+  isDeployed: boolean;
+}, unknown>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useHasV1SmartAccount.d.ts
+declare const getHasV1SmartAccount: (thor: ThorClient, ownerAddress?: string, networkType?: NETWORK_TYPE) => Promise<boolean>;
+declare const getHasV1SmartAccountQueryKey: (ownerAddress?: string, networkType?: NETWORK_TYPE) => (string | undefined)[];
+/**
+ * Check if a smart account has a v1 smart account
+ * @param ownerAddress - The address of the owner of the smart account
+ * @returns True if the smart account has a v1 smart account, false otherwise
+ */
+declare const useHasV1SmartAccount: (ownerAddress?: string) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useIsSmartAccountDeployed.d.ts
+declare const getIsDeployed: (thor: ThorClient, accountAddress?: string) => Promise<boolean>;
+declare const getIsDeployedQueryKey: (contractAddress?: string) => (string | undefined)[];
+/**
+ * Check if a smart account is deployed
+ * @returns True if the smart account is deployed, false otherwise
+ */
+declare const useIsSmartAccountDeployed: (accountAddress?: string) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useRefreshFactoryQueries.d.ts
+/**
+ * Hook to refresh smart account factory-related queries
+ * @returns Object with refresh function
+ */
+declare const useRefreshFactoryQueries: () => {
+  refresh: () => Promise<void>;
+};
+//#endregion
+//#region src/hooks/thor/smartAccounts/useRefreshSmartAccountQueries.d.ts
+/**
+ * Hook to refresh smart account-related queries
+ * @returns Object with refresh function
+ */
+declare const useRefreshSmartAccountQueries: () => {
+  refresh: () => Promise<void>;
+};
+//#endregion
+//#region src/hooks/thor/smartAccounts/useSmartAccount.d.ts
+interface SmartAccountReturnType {
+  address: string | undefined;
+  isDeployed: boolean;
+}
+declare const getSmartAccount: (thor: ThorClient, network: NETWORK_TYPE, ownerAddress?: string) => Promise<{
+  address: undefined;
+  isDeployed?: undefined;
+} | {
+  address: string;
+  isDeployed: boolean;
+}>;
+declare const getSmartAccountQueryKey: (ownerAddress?: string) => (string | undefined)[];
+declare const useSmartAccount: (ownerAddress?: string) => _tanstack_react_query8.UseQueryResult<{
+  address: undefined;
+  isDeployed?: undefined;
+} | {
+  address: string;
+  isDeployed: boolean;
+}, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useUpgradeRequired.d.ts
+declare const getUpgradeRequired: (thor: ThorClient, accountAddress: string, ownerAddress: string, targetVersion: number, networkType: NETWORK_TYPE) => Promise<boolean>;
+declare const getUpgradeRequiredQueryKey: (accountAddress: string, ownerAddress: string, targetVersion: number, networkType: NETWORK_TYPE) => (string | number)[];
+/**
+ * Check if a smart account needs an upgrade (even if it's not yet deployed)
+ * @param accountAddress - The address of the smart account
+ * @param ownerAddress - The address of the owner of the smart account
+ * @param targetVersion - The version of the smart account to check for
+ * @returns True if the smart account needs an upgrade, false otherwise
+ */
+declare const useUpgradeRequired: (accountAddress: string, ownerAddress: string, targetVersion: number) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useUpgradeRequiredForAccount.d.ts
+declare const getUpgradeRequiredForAccount: (thor: ThorClient, contractAddress: string, targetVersion: number, networkType: NETWORK_TYPE) => Promise<boolean>;
+declare const getUpgradeRequiredForAccountQueryKey: (contractAddress: string, targetVersion: number, networkType: NETWORK_TYPE) => (string | number)[];
+/**
+ * Check if a smart account needs an upgrade
+ * @param contractAddress - The address of the smart account
+ * @param targetVersion - The target version of the smart account
+ * @returns True if the smart account needs an upgrade, false otherwise
+ */
+declare const useUpgradeRequiredForAccount: (contractAddress: string, targetVersion: number) => _tanstack_react_query8.UseQueryResult<boolean, Error>;
+//#endregion
+//#region src/hooks/thor/smartAccounts/useUpgradeSmartAccount.d.ts
+type UseUpgradeSmartAccountVersionProps = {
+  smartAccountAddress: string;
+  targetVersion: number;
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+type UseUpgradeSmartAccountVersionReturnValue = {
+  sendTransaction: () => Promise<void>;
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const useUpgradeSmartAccount: ({
+  smartAccountAddress,
+  targetVersion,
+  onSuccess,
+  onError
+}: UseUpgradeSmartAccountVersionProps) => UseUpgradeSmartAccountVersionReturnValue;
+//#endregion
+//#region src/hooks/thor/blocks/useCurrentBlock.d.ts
+declare const currentBlockQueryKey: () => string[];
+/**
+ * Fetches the current block from the blockchain. The block is refetched every 10 seconds.
+ * @returns the current block
+ */
+declare const useCurrentBlock: () => _tanstack_react_query8.UseQueryResult<_vechain_sdk_network0.ExpandedBlockDetail, Error>;
+//#endregion
+//#region src/hooks/thor/blocks/useGetChainId.d.ts
+declare const getChainId: (thor: ThorClient) => Promise<string>;
+declare const getChainIdQueryKey: () => string[];
+/**
+ *  Get the chain id
+ * @returns The chain id
+ */
+declare const useGetChainId: () => _tanstack_react_query8.UseQueryResult<string, Error>;
+//#endregion
+//#region src/hooks/thor/logs/logUtils.d.ts
+/**
+ * Params for getEvents function
+ * @param nodeUrl the node url
+ * @param thor the thor client
+ * @param auctionId  the auction id to get the events
+ * @param order  the order of the events (asc or desc)
+ * @param offset  the offset of the events
+ * @param limit  the limit of the events (max 256)
+ * @param from  the block number to start from
+ * @param filterCriteria  the filter criteria for the events
+ * @returns  the encoded events
+ */
+type GetEventsProps = {
+  nodeUrl: string;
+  thor: ThorClient;
+  order?: 'asc' | 'desc';
+  offset?: number;
+  limit?: number;
+  from?: number;
+  to?: number;
+  filterCriteria: FilterEventLogsOptions['criteriaSet'];
+};
+/**
+ * Get events from blockchain (auction created, auction successful, auction cancelled)
+ * @param order
+ * @param offset
+ * @param limit
+ * @param from block parse start from
+ */
+declare const getEventLogs: ({
+  thor,
+  order,
+  offset,
+  limit,
+  from,
+  to,
+  filterCriteria
+}: GetEventsProps) => Promise<EventLogs[]>;
+/**
+ *  call getEvents iteratively to get all the events
+ * @param nodeUrl the node url
+ * @param thor the thor client
+ * @param order the order of the events (asc or desc)
+ * @param from the block number to start from
+ * @param filterCriteria the filter criteria for the events
+ * @returns all the events from the blockchain
+ */
+declare const getAllEventLogs: ({
+  nodeUrl,
+  thor,
+  order,
+  from,
+  to,
+  filterCriteria
+}: Omit<GetEventsProps, "offset" | "limit">) => Promise<EventLogs[]>;
+//#endregion
+//#region src/hooks/thor/transactions/useSendTransaction.d.ts
+/**
+ * Props for the {@link useSendTransaction} hook
+ * @param signerAccountAddress the signer account to use
+ * @param clauses clauses to send in the transaction
+ * @param onTxConfirmed callback to run when the tx is confirmed
+ * @param onTxFailedOrCancelled callback to run when the tx fails or is cancelled
+ * @param suggestedMaxGas the suggested max gas for the transaction
+ * @param privyUIOptions options to pass to the Privy UI
+ * @param gasPadding the gas padding to use for the transaction (Eg. 0.1 for 10%)
+ */
+type UseSendTransactionProps = {
+  signerAccountAddress?: string | null;
+  clauses?: TransactionClause[];
+  onTxConfirmed?: () => void | Promise<void>;
+  onTxFailedOrCancelled?: (error?: Error | string) => void | Promise<void>;
+  suggestedMaxGas?: number;
+  privyUIOptions?: {
+    title?: string;
+    description?: string;
+    buttonText?: string;
+  };
+  gasPadding?: number;
+};
+/**
+ * Return value of the {@link useSendTransaction} hook
+ * @param sendTransaction function to trigger the transaction
+ * @param isTransactionPending boolean indicating if the transaction is waiting for the wallet to sign it
+ * @param isWaitingForWalletConfirmation boolean indicating if the transaction is waiting for the wallet to confirm it
+ * @param txReceipt the transaction receipt
+ * @param status the status of the transaction (see {@link TransactionStatus})
+ * @param resetStatus function to reset the status to "ready"
+ * @param error error that occurred while sending the transaction
+ */
+type UseSendTransactionReturnValue = {
+  sendTransaction: (clauses?: TransactionClause[]) => Promise<void>;
+  isTransactionPending: boolean;
+  isWaitingForWalletConfirmation: boolean;
+  txReceipt: TransactionReceipt | null;
+  status: TransactionStatus;
+  resetStatus: () => void;
+  error?: TransactionStatusErrorType;
+};
+/**
+ * Generic hook to send a transaction using dapp-kit-react.
+ * This hook supports both Privy and VeChain wallets.
+ *
+ * It returns a function to send the transaction and a status to indicate the state
+ * of the transaction (together with the transaction id).
+ *
+ * * ⚠️ IMPORTANT: When using this hook with Privy cross-app connections, ensure all
+ * data fetching is done before triggering the transaction. Fetching data after
+ * the transaction is triggered may cause browser popup blocking. Pre-fetch any
+ * required data and pass it to your transaction building logic.
+ *
+ * @example
+ * ```typescript
+ * // ❌ Bad: Fetching during transaction
+ * const sendTx = async () => {
+ *   const data = await fetchSomeData(); // May cause popup blocking
+ *   return sendTransaction(data);
+ * };
+ *
+ * // ✅ Good: Pre-fetch data
+ * const { data } = useQuery(['someData'], fetchSomeData);
+ * const sendTx = () => sendTransaction(data); // No async operations
+ * ```
+ *
+ * @param signerAccount the signer account to use
+ * @param clauses clauses to send in the transaction
+ * @param onTxConfirmed callback to run when the tx is confirmed
+ * @param onTxFailedOrCancelled callback to run when the tx fails or is cancelled
+ * @param suggestedMaxGas the suggested max gas for the transaction
+ * @param privyUIOptions options to pass to the Privy UI
+ * @param gasPadding the gas padding to use for the transaction (Eg. 0.1 for 10%)
+ * @returns see {@link UseSendTransactionReturnValue}
+ */
+declare const useSendTransaction: ({
+  signerAccountAddress,
+  clauses,
+  onTxConfirmed,
+  onTxFailedOrCancelled,
+  suggestedMaxGas,
+  privyUIOptions,
+  gasPadding
+}: UseSendTransactionProps) => UseSendTransactionReturnValue;
+//#endregion
+//#region src/hooks/thor/transactions/useTransferERC20.d.ts
+type useTransferERC20Props = {
+  fromAddress: string;
+  receiverAddress: string;
+  amount: string;
+  tokenAddress: string;
+  tokenName: string;
+  onSuccess?: () => void;
+  onSuccessMessageTitle?: number;
+  onError?: (error?: string) => void;
+};
+type useTransferERC20ReturnValue = {
+  sendTransaction: () => Promise<void>;
+  clauses: EnhancedClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const buildERC20Clauses: (receiverAddress: string, amount: string, tokenAddress: string, tokenName: string) => EnhancedClause[];
+declare const useTransferERC20: ({
+  fromAddress,
+  receiverAddress,
+  amount,
+  tokenAddress,
+  tokenName,
+  onSuccess,
+  onError
+}: useTransferERC20Props) => useTransferERC20ReturnValue;
+//#endregion
+//#region src/hooks/thor/transactions/useTransferVET.d.ts
+type useTransferVETProps = {
+  fromAddress: string;
+  receiverAddress: string;
+  amount: string;
+  onSuccess?: () => void;
+  onError?: (error?: string) => void;
+};
+type useTransferVETReturnValue = {
+  sendTransaction: () => Promise<void>;
+  clauses: EnhancedClause[];
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const buildVETClauses: (receiverAddress: string, amount: string) => EnhancedClause[];
+declare const useTransferVET: ({
+  fromAddress,
+  receiverAddress,
+  amount,
+  onSuccess,
+  onError
+}: useTransferVETProps) => useTransferVETReturnValue;
+//#endregion
+//#region src/hooks/thor/transactions/useBuildTransaction.d.ts
+type BuildTransactionProps<ClausesParams> = {
+  clauseBuilder: (props: ClausesParams) => TransactionClause[];
+  refetchQueryKeys?: (string | undefined)[][];
+  onSuccess?: () => void;
+  invalidateCache?: boolean;
+  suggestedMaxGas?: number;
+  gasPadding?: number;
+  onFailure?: () => void;
+};
+/**
+ * Custom hook for building and sending transactions.
+ * @param clauseBuilder - A function that builds an array of enhanced clauses based on the provided parameters.
+ * @param refetchQueryKeys - An optional array of query keys to refetch after the transaction is sent.
+ * @param invalidateCache - A flag indicating whether to invalidate the cache and refetch queries after the transaction is sent.
+ * @param onSuccess - An optional callback function to be called after the transaction is successfully sent.
+ * @param onFailure - An optional callback function to be called after the transaction is failed or cancelled.
+ * @param suggestedMaxGas - The suggested maximum gas for the transaction.
+ * @param gasPadding - The padding to add to the suggested maximum gas.
+ * @returns An object containing the result of the `useSendTransaction` hook and a `sendTransaction` function.
+ */
+declare const useBuildTransaction: <ClausesParams>({
+  clauseBuilder,
+  refetchQueryKeys,
+  invalidateCache,
+  onSuccess,
+  onFailure,
+  suggestedMaxGas,
+  gasPadding
+}: BuildTransactionProps<ClausesParams>) => {
+  sendTransaction: (props: ClausesParams) => Promise<void>;
+  isTransactionPending: boolean;
+  isWaitingForWalletConfirmation: boolean;
+  txReceipt: _vechain_sdk_network0.TransactionReceipt | null;
+  status: TransactionStatus;
+  resetStatus: () => void;
+  error?: TransactionStatusErrorType;
+};
+//#endregion
+//#region src/hooks/thor/transactions/useTxReceipt.d.ts
+declare const txReceiptQueryKey: (txId: string) => string[];
+/**
+ * Retrieve the receipt of a transaction identified by its ID.
+ * If the transaction is not found, the response will be null.
+ * @param txId The ID of the transaction to retrieve the receipt for
+ * @param blockTimeout Optional timeout in milliseconds to stop polling for receipt
+ * @returns Query result containing the transaction receipt
+ */
+declare const useTxReceipt: (txId: string, blockTimeout?: number) => _tanstack_react_query8.UseQueryResult<_vechain_sdk_network0.TransactionReceipt, Error>;
+//#endregion
+//#region src/components/AccountModal/Contents/SendToken/SendTokenContent.d.ts
+type SendTokenContentProps = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<AccountModalContentTypes>>;
+  preselectedToken?: TokenWithValue;
+  initialAmount?: string;
+  initialToAddressOrDomain?: string;
+  onBack?: () => void;
+};
+declare const SendTokenContent: ({
+  setCurrentContent,
+  preselectedToken,
+  initialAmount,
+  initialToAddressOrDomain,
+  onBack: parentOnBack
+}: SendTokenContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/SendToken/SendTokenSummaryContent.d.ts
+type SendTokenSummaryContentProps = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<AccountModalContentTypes>>;
+  toAddressOrDomain: string;
+  resolvedDomain?: string;
+  resolvedAddress?: string;
+  amount: string;
+  selectedToken: TokenWithValue;
+  formattedTotalAmount: string;
+};
+declare const SendTokenSummaryContent: ({
+  setCurrentContent,
+  toAddressOrDomain,
+  resolvedDomain,
+  resolvedAddress,
+  amount,
+  selectedToken,
+  formattedTotalAmount
+}: SendTokenSummaryContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/SendToken/SelectTokenContent.d.ts
+type Props$18 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  onSelectToken: (token: TokenWithValue) => void;
+  onBack: () => void;
+  /**
+   * If true, shows all tokens (not just tokens with balance) and sorts owned tokens first
+   */
+  showAllTokens?: boolean;
+};
+declare const SelectTokenContent: ({
+  onSelectToken,
+  onBack,
+  showAllTokens
+}: Props$18) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Receive/ReceiveTokenContent.d.ts
+type Props$17 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const ReceiveTokenContent: ({
+  setCurrentContent
+}: Props$17) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Swap/SwapTokenContent.d.ts
+type Props$16 = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<AccountModalContentTypes>>;
+  fromTokenAddress?: string;
+  toTokenAddress?: string;
+};
+declare const SwapTokenContent: ({
+  setCurrentContent,
+  fromTokenAddress,
+  toTokenAddress
+}: Props$16) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/ChooseName/ChooseNameContent.d.ts
+type ChooseNameContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  onBack?: () => void;
+  initialContentSource?: AccountModalContentTypes;
+};
+declare const ChooseNameContent: ({
+  setCurrentContent,
+  onBack,
+  initialContentSource
+}: ChooseNameContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/ChooseName/ChooseNameSearchContent.d.ts
+type ChooseNameSearchContentProps = {
+  name: string;
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  initialContentSource?: AccountModalContentTypes;
+};
+declare const ChooseNameSearchContent: ({
+  name: initialName,
+  setCurrentContent,
+  initialContentSource
+}: ChooseNameSearchContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/ChooseName/ChooseNameSummaryContent.d.ts
+type ChooseNameSummaryContentProps = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<AccountModalContentTypes>>;
+  fullDomain: string;
+  domainType?: string;
+  isOwnDomain: boolean;
+  isUnsetting?: boolean;
+  initialContentSource?: AccountModalContentTypes;
+};
+declare const ChooseNameSummaryContent: ({
+  setCurrentContent,
+  fullDomain,
+  domainType,
+  isOwnDomain,
+  isUnsetting,
+  initialContentSource
+}: ChooseNameSummaryContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/FAQ/FAQContent.d.ts
+type FAQContentProps = {
+  onGoBack: () => void;
+  showLanguageSelector?: boolean;
+};
+declare const FAQContent: ({
+  onGoBack,
+  showLanguageSelector
+}: FAQContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Profile/Customization/CustomizationContent.d.ts
+type AccountCustomizationContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  initialContentSource?: AccountModalContentTypes;
+};
+declare const CustomizationContent: ({
+  setCurrentContent,
+  initialContentSource
+}: AccountCustomizationContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Profile/Customization/CustomizationSummaryContent.d.ts
+type CustomizationSummaryContentProps = {
+  setCurrentContent: React$1.Dispatch<React$1.SetStateAction<AccountModalContentTypes>>;
+  changes: {
+    avatarIpfsHash?: string | null;
+    displayName?: string;
+    description?: string;
+    twitter?: string;
+    website?: string;
+    email?: string;
+  };
+  onDoneRedirectContent: AccountModalContentTypes;
+};
+declare const CustomizationSummaryContent: ({
+  setCurrentContent,
+  changes,
+  onDoneRedirectContent
+}: CustomizationSummaryContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Profile/ProfileContent.d.ts
+type ProfileContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  onLogoutSuccess: () => void;
+};
+declare const ProfileContent: ({
+  setCurrentContent,
+  onLogoutSuccess
+}: ProfileContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/UpgradeSmartAccount/UpgradeSmartAccountContent.d.ts
+type UpgradeSmartAccountContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  handleClose?: () => void;
+  initialContent?: AccountModalContentTypes;
+};
+declare const UpgradeSmartAccountContent: ({
+  setCurrentContent,
+  handleClose,
+  initialContent
+}: UpgradeSmartAccountContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Assets/AssetsContent.d.ts
+type AssetsContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const AssetsContent: ({
+  setCurrentContent
+}: AssetsContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Assets/ManageCustomTokenContent.d.ts
+type ManageCustomTokenContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const ManageCustomTokenContent: ({
+  setCurrentContent
+}: ManageCustomTokenContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Bridge/BridgeContent.d.ts
+type Props$15 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const BridgeContent: ({
+  setCurrentContent
+}: Props$15) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/KitSettings/ChangeCurrencyContent.d.ts
+type ChangeCurrencyContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const ChangeCurrencyContent: ({
+  setCurrentContent
+}: ChangeCurrencyContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/KitSettings/GeneralSettingsContent.d.ts
+type Props$14 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const GeneralSettingsContent: ({
+  setCurrentContent
+}: Props$14) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/KitSettings/LanguageSettingsContent.d.ts
+type Props$13 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const LanguageSettingsContent: ({
+  setCurrentContent
+}: Props$13) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/KitSettings/AppearanceSettingsContent.d.ts
+type Props$12 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const AppearanceSettingsContent: ({
+  setCurrentContent
+}: Props$12) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/KitSettings/GasTokenSettingsContent.d.ts
+type Props$11 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const GasTokenSettingsContent: ({
+  setCurrentContent
+}: Props$11) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/TermsAndPrivacy/TermsAndPrivacyContent.d.ts
+type TermsAndPrivacyContentProps = {
+  onGoBack: () => void;
+};
+declare const TermsAndPrivacyContent: ({
+  onGoBack
+}: TermsAndPrivacyContentProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Contents/Ecosystem/Components/CategoryFilterSection.d.ts
+type CategoryFilter = string | null;
+//#endregion
+//#region src/components/AccountModal/Contents/Ecosystem/AppOverviewContent.d.ts
+type AppOverviewContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  name: string;
+  image: string;
+  url: string;
+  description: string;
+  category?: AllowedCategories;
+  selectedCategory?: CategoryFilter;
+  logoComponent?: JSX.Element;
+};
+//#endregion
+//#region src/components/AccountModal/Contents/SuccessfulOperation/SuccessfulOperationContent.d.ts
+type SuccessfulOperationContentProps$1 = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  txId?: string;
+  title: string;
+  description?: string;
+  onDone: () => void;
+  showSocialButtons?: boolean;
+};
+//#endregion
+//#region src/components/AccountModal/Contents/FailedOperation/FailedOperationContent.d.ts
+type FailedOperationContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  txId?: string;
+  title: string;
+  description?: string;
+  onDone: () => void;
+};
+//#endregion
+//#region src/components/AccountModal/Types/Types.d.ts
+type AccountModalContentTypes = 'main' | 'settings' | 'profile' | 'access-and-security' | 'embedded-wallet' | 'manage-mfa' | 'receive-token' | 'swap-token' | 'connection-details' | 'ecosystem' | 'notifications' | 'privy-linked-accounts' | 'add-custom-token' | 'assets' | 'bridge' | 'change-currency' | 'general-settings' | 'change-language' | 'appearance-settings' | 'gas-token-settings' | {
+  type: 'swap-token';
+  props: {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    fromTokenAddress?: string;
+    toTokenAddress?: string;
+  };
+} | {
+  type: 'account-customization';
+  props: AccountCustomizationContentProps;
+} | {
+  type: 'successful-operation';
+  props: SuccessfulOperationContentProps$1;
+} | {
+  type: 'failed-operation';
+  props: FailedOperationContentProps;
+} | {
+  type: 'account-customization-summary';
+  props: CustomizationSummaryContentProps;
+} | {
+  type: 'app-overview';
+  props: AppOverviewContentProps;
+} | {
+  type: 'ecosystem-with-category';
+  props: {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    selectedCategory: CategoryFilter;
+  };
+} | {
+  type: 'send-token';
+  props: SendTokenContentProps;
+} | {
+  type: 'send-token-summary';
+  props: SendTokenSummaryContentProps;
+} | {
+  type: 'choose-name';
+  props: ChooseNameContentProps;
+} | {
+  type: 'choose-name-search';
+  props: ChooseNameSearchContentProps;
+} | {
+  type: 'choose-name-summary';
+  props: ChooseNameSummaryContentProps;
+} | {
+  type: 'disconnect-confirm';
+  props: DisconnectConfirmContentProps;
+} | {
+  type: 'upgrade-smart-account';
+  props: UpgradeSmartAccountContentProps;
+} | {
+  type: 'faq';
+  props: FAQContentProps;
+} | {
+  type: 'terms-and-privacy';
+  props: TermsAndPrivacyContentProps;
+};
+//#endregion
+//#region src/components/AccountModal/AccountModal.d.ts
+type Props$10 = {
+  isOpen: boolean;
+  onClose: () => void;
+  initialContent?: AccountModalContentTypes;
+};
+declare const AccountModal: ({
+  isOpen,
+  onClose,
+  initialContent
+}: Props$10) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/AccountDetailsButton.d.ts
+interface AccountDetailsButtonProps {
+  title: string;
+  wallet: Wallet;
+  onClick: () => void;
+  leftIcon?: ElementType;
+  rightIcon?: ElementType;
+  leftImage?: string;
+  backgroundColor?: string;
+  border?: string;
+  isActive?: boolean;
+}
+declare const AccountDetailsButton: ({
+  leftIcon,
+  rightIcon,
+  title,
+  wallet,
+  onClick,
+  leftImage,
+  isActive
+}: AccountDetailsButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/ActionButton.d.ts
+type ActionButtonProps = {
+  title: string;
+  description?: string;
+  onClick: () => void;
+  leftIcon?: IconType;
+  rightIcon?: IconType;
+  leftImage?: string;
+  backgroundColor?: string;
+  border?: string;
+  hide?: boolean;
+  _hover?: object;
+  showComingSoon?: boolean;
+  isDisabled?: boolean;
+  stacked?: boolean;
+  isLoading?: boolean;
+  loadingText?: string;
+  style?: ButtonProps;
+  extraContent?: React.ReactNode;
+  dataTestId?: string;
+  variant?: string;
+};
+declare const ActionButton: ({
+  leftIcon,
+  rightIcon,
+  title,
+  onClick,
+  leftImage,
+  hide,
+  showComingSoon,
+  backgroundColor,
+  _hover,
+  isDisabled,
+  stacked,
+  isLoading,
+  loadingText,
+  style,
+  extraContent,
+  dataTestId,
+  variant
+}: ActionButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/AccountSelector.d.ts
+type Props$9 = {
+  wallet: Wallet;
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  size?: string;
+  onClick?: () => void;
+  onClose: () => void;
+  mt?: number;
+  style?: StackProps;
+};
+declare const AccountSelector: ({
+  wallet,
+  setCurrentContent,
+  size,
+  onClick,
+  onClose,
+  mt,
+  style
+}: Props$9) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/BalanceSection.d.ts
+declare const BalanceSection: ({
+  mb,
+  mt,
+  onAssetsClick
+}: {
+  mb?: number;
+  mt?: number;
+  onAssetsClick?: () => void;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/QuickActionsSection.d.ts
+type Props$8 = {
+  mt?: number;
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const QuickActionsSection: ({
+  mt,
+  setCurrentContent
+}: Props$8) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/Alerts/FeatureAnnouncementCard.d.ts
+type FeatureAnnouncementCardProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const FeatureAnnouncementCard: ({
+  setCurrentContent
+}: FeatureAnnouncementCardProps) => react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/AccountModal/Components/Alerts/ExchangeWarningAlert.d.ts
+declare const ExchangeWarningAlert: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/Alerts/DomainRequiredAlert.d.ts
+declare const DomainRequiredAlert: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/AccountModal/Components/CrossAppConnectionSecurityCard.d.ts
+declare const CrossAppConnectionSecurityCard: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/ModalBackButton.d.ts
+type BackButtonProps = {
+  onClick: () => void;
+} & Partial<IconButtonProps>;
+declare const ModalBackButton: ({
+  onClick,
+  ...props
+}: BackButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/AddressDisplay.d.ts
+type Props$7 = {
+  wallet: Wallet;
+  label?: string;
+  style?: PropsOf<typeof VStack>;
+  showHumanAddress?: boolean;
+};
+declare const AddressDisplay: ({
+  wallet,
+  label,
+  style,
+  showHumanAddress
+}: Props$7) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/VersionFooter.d.ts
+type Props$6 = {} & Omit<StackProps, 'dangerouslySetInnerHTML'>;
+declare const VersionFooter: ({
+  ...props
+}: Props$6) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/StickyHeaderContainer.d.ts
+type Props$5 = {
+  children: React.ReactNode;
+};
+declare const StickyHeaderContainer: ({
+  children
+}: Props$5) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/StickyFooterContainer.d.ts
+type Props$4 = {
+  children: React.ReactNode;
+};
+declare const StickyFooterContainer: ({
+  children
+}: Props$4) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/BaseModal.d.ts
+type BaseModalProps = {
+  isOpen: boolean;
+  onClose: () => void;
+  children: ReactNode;
+  size?: string;
+  isCentered?: boolean;
+  motionPreset?: 'slideInBottom' | 'none';
+  trapFocus?: boolean;
+  closeOnOverlayClick?: boolean;
+  blockScrollOnMount?: boolean;
+  autoFocus?: boolean;
+  initialFocusRef?: React.RefObject<HTMLElement>;
+  allowExternalFocus?: boolean;
+  backdropFilter?: string;
+  isCloseable?: boolean;
+};
+declare const BaseModal: ({
+  isOpen,
+  onClose,
+  children,
+  size,
+  isCentered,
+  motionPreset,
+  closeOnOverlayClick,
+  blockScrollOnMount,
+  allowExternalFocus,
+  backdropFilter,
+  isCloseable
+}: BaseModalProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/AssetButton.d.ts
+type AssetButtonProps = ButtonProps & {
+  symbol: string;
+  amount: number;
+  currencyValue: number;
+  currentCurrency: CURRENCY;
+  isDisabled?: boolean;
+  onClick?: () => void;
+};
+declare const AssetButton: ({
+  symbol,
+  amount,
+  currencyValue,
+  currentCurrency,
+  isDisabled,
+  onClick,
+  ...buttonProps
+}: AssetButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/AddressDisplayCard.d.ts
+type AddressDisplayCardProps = {
+  label: string;
+  address: string;
+  domain?: string;
+  imageSrc: string;
+  imageAlt?: string;
+  hideAddress?: boolean;
+  balance?: number;
+  tokenAddress?: string;
+};
+declare const AddressDisplayCard: ({
+  label,
+  address,
+  domain,
+  imageSrc,
+  imageAlt,
+  hideAddress,
+  balance,
+  tokenAddress
+}: AddressDisplayCardProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/ModalFAQButton.d.ts
+type FAQButtonProps = {
+  onClick: () => void;
+} & Partial<IconButtonProps>;
+declare const ModalFAQButton: ({
+  onClick,
+  ...props
+}: FAQButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/ScrollToTopWrapper.d.ts
+declare const ScrollToTopWrapper: ({
+  children,
+  ...props
+}: StackProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/AccountAvatar.d.ts
+type AccountAvatarProps = {
+  wallet?: Wallet;
+  props?: ImageProps;
+};
+declare const AccountAvatar: ({
+  wallet,
+  props
+}: AccountAvatarProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/TransactionButtonAndStatus.d.ts
+type TransactionButtonAndStatusProps = {
+  isSubmitting: boolean;
+  isTxWaitingConfirmation: boolean;
+  onConfirm: () => void;
+  onRetry?: () => void;
+  transactionPendingText: string;
+  txReceipt: TransactionReceipt | null;
+  transactionError?: Error | TransactionStatusErrorType | null;
+  isSubmitForm?: boolean;
+  buttonText: string;
+  isDisabled?: boolean;
+  style?: {
+    accentColor?: string;
+  };
+  onError?: (error: string) => void;
+  gasEstimationError?: Error | null;
+  hasEnoughGasBalance?: boolean;
+  isLoadingGasEstimation?: boolean;
+  showGasEstimationError?: boolean;
+  context?: 'send' | 'customization' | 'domain' | 'transaction';
+};
+declare const TransactionButtonAndStatus: ({
+  transactionError,
+  isSubmitting,
+  isTxWaitingConfirmation,
+  onConfirm,
+  onRetry,
+  transactionPendingText,
+  txReceipt,
+  isSubmitForm,
+  buttonText,
+  isDisabled,
+  style,
+  onError,
+  gasEstimationError,
+  hasEnoughGasBalance,
+  isLoadingGasEstimation,
+  showGasEstimationError,
+  context
+}: TransactionButtonAndStatusProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/ModalNotificationButton.d.ts
+type NotificationButtonProps = {
+  onClick: () => void;
+  hasUnreadNotifications?: boolean;
+} & Partial<IconButtonProps>;
+declare const ModalNotificationButton: ({
+  onClick,
+  hasUnreadNotifications,
+  ...props
+}: NotificationButtonProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/common/GasFeeSummary.d.ts
+interface GasFeeSummaryProps {
+  estimation: (EstimationResponse & {
+    usedToken: string;
+  }) | undefined;
+  isLoading: boolean | undefined;
+  isLoadingTransaction?: boolean;
+  onTokenChange?: (token: GasTokenType) => void;
+  clauses?: TransactionClause[];
+  userSelectedToken?: GasTokenType | null;
+}
+declare const GasFeeSummary: React$1.FC<GasFeeSummaryProps>;
+//#endregion
+//#region src/components/common/GasFeeTokenSelector.d.ts
+interface GasFeeTokenSelectorProps {
+  isOpen: boolean;
+  onClose: () => void;
+  selectedToken: GasTokenType;
+  onTokenSelect: (token: GasTokenType, rememberChoice: boolean) => void;
+  availableTokens: GasTokenType[];
+  tokenEstimations: Record<GasTokenType, {
+    cost: number;
+    loading: boolean;
+  }>;
+  walletAddress: string;
+}
+declare const GasFeeTokenSelector: ({
+  isOpen,
+  onClose,
+  selectedToken,
+  onTokenSelect,
+  availableTokens,
+  tokenEstimations,
+  walletAddress
+}: GasFeeTokenSelectorProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/LoginLoadingModal/LoginLoadingModal.d.ts
+type LoginLoadingModalProps = {
+  isOpen: boolean;
+  onClose: () => void;
+  error?: string;
+  title?: string;
+  loadingText?: string;
+  onTryAgain?: () => void;
+};
+declare const LoginLoadingModal: ({
+  isOpen,
+  onClose,
+  error,
+  title,
+  loadingText,
+  onTryAgain
+}: LoginLoadingModalProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/EcosystemModal/EcosystemModal.d.ts
+type Props$3 = {
+  isOpen: boolean;
+  onClose: () => void;
+  appsInfo: PrivyAppInfo[];
+  isLoading: boolean;
+};
+declare const EcosystemModal: ({
+  isOpen,
+  onClose,
+  appsInfo,
+  isLoading
+}: Props$3) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/UpgradeSmartAccountModal/Contents/SuccessfulOperationContent.d.ts
+type SuccessfulOperationContentProps = {
+  setCurrentContent: React.Dispatch<React.SetStateAction<UpgradeSmartAccountModalContentsTypes>>;
+  txId?: string;
+  title: string;
+  description?: string;
+  onDone: () => void;
+  showSocialButtons?: boolean;
+};
+//#endregion
+//#region src/components/UpgradeSmartAccountModal/UpgradeSmartAccountModal.d.ts
+type UpgradeSmartAccountModalStyle = {
+  accentColor?: string;
+  modalSize?: ThemeTypings['components']['Modal']['sizes'];
+};
+type Props$2 = {
+  isOpen: boolean;
+  onClose: () => void;
+  style?: UpgradeSmartAccountModalStyle;
+};
+type UpgradeSmartAccountModalContentsTypes = 'upgrade-smart-account' | {
+  type: 'successful-operation';
+  props: SuccessfulOperationContentProps;
+};
+declare const UpgradeSmartAccountModal: ({
+  isOpen,
+  onClose,
+  style
+}: Props$2) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/LegalDocumentsModal/LegalDocumentsModal.d.ts
+type Props$1 = {
+  isOpen: boolean;
+  onAgree: (documents: EnrichedLegalDocument | EnrichedLegalDocument[]) => void;
+  handleLogout: () => void;
+  onlyOptionalDocuments?: boolean;
+};
+type LegalDocumentsModalContentsTypes = 'legal-documents';
+declare const LegalDocumentsModal: ({
+  isOpen,
+  onAgree,
+  handleLogout,
+  onlyOptionalDocuments
+}: Props$1) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/LegalDocumentsModal/Components/LegalDocumentItem.d.ts
+type Props = {
+  document: EnrichedLegalDocument;
+  register: UseFormRegister<any>;
+  isText?: boolean;
+};
+declare const LegalDocumentItem: ({
+  document,
+  register,
+  isText
+}: Props) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/providers/ModalProvider.d.ts
+type AccountModalOptions = {
+  isolatedView?: boolean;
+};
+type ModalContextType = {
+  openConnectModal: () => void;
+  closeConnectModal: () => void;
+  isConnectModalOpen: boolean;
+  openAccountModal: (content?: AccountModalContentTypes, options?: AccountModalOptions) => void;
+  closeAccountModal: () => void;
+  isAccountModalOpen: boolean;
+  accountModalContent: AccountModalContentTypes;
+  setAccountModalContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+  isolatedView: boolean;
+  openTransactionModal: () => void;
+  closeTransactionModal: () => void;
+  isTransactionModalOpen: boolean;
+  openTransactionToast: () => void;
+  closeTransactionToast: () => void;
+  isTransactionToastOpen: boolean;
+  openUpgradeSmartAccountModal: (style?: UpgradeSmartAccountModalStyle) => void;
+  closeUpgradeSmartAccountModal: () => void;
+  isUpgradeSmartAccountModalOpen: boolean;
+};
+declare const useModal: () => ModalContextType;
+declare const ModalProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/config/index.d.ts
+type AppConfig = {
+  ipfsFetchingService: string;
+  ipfsPinningService: string;
+  vthoContractAddress: string;
+  b3trContractAddress: string;
+  vot3ContractAddress: string;
+  b3trGovernorAddress: string;
+  timelockContractAddress: string;
+  xAllocationPoolContractAddress: string;
+  xAllocationVotingContractAddress: string;
+  emissionsContractAddress: string;
+  voterRewardsContractAddress: string;
+  galaxyMemberContractAddress: string;
+  treasuryContractAddress: string;
+  x2EarnAppsContractAddress: string;
+  x2EarnCreatorContractAddress: string;
+  x2EarnRewardsPoolContractAddress: string;
+  nodeManagementContractAddress: string;
+  veBetterPassportContractAddress: string;
+  veDelegate: string;
+  veDelegateVotes: string;
+  veDelegateTokenContractAddress: string;
+  oracleContractAddress: string;
+  accountFactoryAddress: string;
+  cleanifyCampaignsContractAddress: string;
+  cleanifyChallengesContractAddress: string;
+  veWorldSubdomainClaimerContractAddress: string;
+  vetDomainsContractAddress: string;
+  vetDomainsPublicResolverAddress: string;
+  vetDomainsReverseRegistrarAddress: string;
+  vnsResolverAddress: string;
+  gloDollarContractAddress: string;
+  vetDomainAvatarUrl: string;
+  nodeUrl: string;
+  indexerUrl: string;
+  b3trIndexerUrl: string;
+  graphQlIndexerUrl: string;
+  network: Network;
+  explorerUrl: string;
+};
+declare const getConfig: (env: NETWORK_TYPE) => AppConfig;
+//#endregion
+export { AssetsContentProps as $, getCustomTokenInfoQueryKey as $a, useChooseNameModal as $i, useGetNodeUrl as $n, EmbeddedWalletContent as $o, getPicassoImage as $r, formatGasCost as $s, getSmartAccount as $t, ModalBackButton as A, getXAppMetadata as Aa, useAccountModalOptions as Ai, delegateAuthorized as An, getAvatarQueryKey as Ao, validate as Ar, VechainKitThemeProvider as As, useBuildTransaction as At, AccountModal as B, XApp as Ba, FAQModalProvider as Bi, LocalStorageKey as Bn, useClaimVetDomain as Bo, xNodeToGMstartingLevel as Br, useVeChainKitConfig as Bs, getChainId as Bt, AddressDisplayCard as C, useIpfsImageList as Ca, VePassportUserStatus as Cc, useLoginWithVeChain as Ci, useAccountBalance as Cn, getResolverAddressQueryKey as Co, isValidUrl as Cr, ConnectionButton as Cs, useMfaEnrollment as Ct, StickyHeaderContainer as D, getXAppsSharesQueryKey as Da, useSignMessage as Di, useGasEstimation as Dn, getTextRecords as Do, isValid as Dr, LegalDocumentsProvider as Ds, txReceiptQueryKey as Dt, StickyFooterContainer as E, useIpfsMetadata as Ea, useSignTypedData as Ei, UseGasEstimationParams as En, useUpdateTextRecord as Eo, isInvalid as Er, ConnectModalContentsTypes as Es, useThor as Et, QuickActionsSection as F, getRoundXAppsQueryKey as Fa, useLoginModalContent as Fi, useGenericDelegator as Fn, getDomainsOfAddressQueryKey as Fo, NodeStrengthLevelToImage as Fr, LegalDocument as Fs, UseSendTransactionReturnValue as Ft, LanguageSettingsContent as G, useGetVot3Balance as Ga, useExploreEcosystemModal as Gi, useBuildClauses as Gn, useVechainDomain as Go, validateIpfsUri as Gr, CostLevel as Gs, useUpgradeSmartAccount as Gt, TermsAndPrivacyContent as H, getIsPersonQueryKey as Ha, NotificationsModalProvider as Hi, BuildClausesParams as Hn, getEnsRecordExistsQueryKey as Ho, resolveMediaTypeFromMimeType as Hr, LegalDocumentAgreement as Hs, useGetChainId as Ht, BalanceSection as I, useRoundXApps as Ia, ReceiveModalProvider as Ii, useCrossAppConnectionCache as In, useGetDomainsOfAddress as Io, XNodeStrengthLevelToName as Ir, LegalDocumentOptions as Is, useSendTransaction as It, ChangeCurrencyContentProps as J, getTokenUsdPrice as Ja, SwapTokenModalProvider as Ji, decodeEventLog$1 as Jn, fetchPrivyAppInfo as Jo, isValidAddress as Jr, EstimationResponse as Js, useUpgradeRequiredForAccount as Jt, GeneralSettingsContent as K, PRICE_FEED_IDS as Ka, AccessAndSecurityModalProvider as Ki, GetEventsKeyParams as Kn, fetchPrivyStatus as Ko, compareAddresses as Kr, DepositAccount as Ks, getUpgradeRequiredForAccount as Kt, AccountSelector as L, useRefreshMetadata as La, useReceiveModal as Li, EcosystemShortcut as Ln, getIsDomainProtectedQueryKey as Lo, allNodeStrengthLevelToName as Lr, VeChainKitContext as Ls, GetEventsProps as Lt, DomainRequiredAlert as M, useWalletMetadata as Ma, useProfileModal as Mi, estimateGas as Mn, Domain as Mo, TIME as Mr, PrivyWalletProvider as Ms, useTransferVET as Mt, ExchangeWarningAlert as N, UseWalletReturnType as Na, UpgradeSmartAccountModalProvider as Ni, getDepositAccount as Nn, DomainsResponse as No, EconomicNodeStrengthLevelToName as Nr, PrivyWalletProviderContextType as Ns, buildERC20Clauses as Nt, VersionFooter as O, useXAppsShares as Oa, useNotificationAlerts as Oi, useGasTokenSelection as On, getTextRecordsQueryKey as Oo, normalize as Or, useLegalDocuments as Os, useTxReceipt as Ot, FeatureAnnouncementCard as P, useWallet as Pa, useUpgradeSmartAccountModal as Pi, signVip191Transaction as Pn, getDomainsOfAddress as Po, MinXNodeLevel as Pr, usePrivyWalletProvider as Ps, useTransferERC20 as Pt, AssetsContent as Q, useGetErc20Balance as Qa, ChooseNameModalProvider as Qi, useIsPWA as Qn, DisconnectConfirmContentProps as Qo, formatTokenBalance as Qr, calculateTotalCost as Qs, SmartAccountReturnType as Qt, ActionButton as R, useRefreshBalances as Ra, AccountCustomizationModalProvider as Ri, useEcosystemShortcuts as Rn, useIsDomainProtected as Ro, buildQueryString as Rr, VeChainKitProvider as Rs, getAllEventLogs as Rt, ModalFAQButton as S, useIpfsImage as Sa, TransactionStatusErrorType as Sc, useAppHubApps as Si, getAccountBalanceQueryKey as Sn, useGetAvatarOfAddress as So, executeMultipleClausesCall as Sr, EmailLoginButton as Ss, useDAppKitWalletModal as St, BaseModal as T, getIpfsMetadataQueryKey as Ta, useLoginWithPasskey as Ti, useEstimateAllTokens as Tn, buildClauses as To, compare as Tr, ConnectModal as Ts, useSetWalletRecovery as Tt, GasTokenSettingsContent as U, useIsPerson as Ua, useNotificationsModal as Ui, buildBatchAuthorizationTypedData as Un, useEnsRecordExists as Uo, toIPFSURL as Ur, LegalDocumentSource as Us, currentBlockQueryKey as Ut, AccountModalContentTypes as V, useMostVotedAppsInRound as Va, useFAQModal as Vi, useLocalStorage as Vn, useClaimVeWorldSubdomain as Vo, convertUriToUrl as Vr, EnrichedLegalDocument as Vs, getChainIdQueryKey as Vt, AppearanceSettingsContent as W, getVot3BalanceQueryKey as Wa, ExploreEcosystemModalProvider as Wi, buildSingleAuthorizationTypedData as Wn, getVechainDomainQueryKey as Wo, uploadBlobToIPFS as Wr, LegalDocumentType as Ws, useCurrentBlock as Wt, ManageCustomTokenContent as X, useGetTokenUsdPrice as Xa, SendTokenModalProvider as Xi, useEvents as Xn, useFetchAppInfo as Xo, regexPattern as Xr, TransactionCost as Xs, getUpgradeRequiredQueryKey as Xt, BridgeContent as Y, getTokenUsdPriceQueryKey as Ya, useSwapTokenModal as Yi, getEventsKey as Yn, getPrivyAppInfoQueryKey as Yo, leftPadWithZeros as Yr, Rate as Ys, getUpgradeRequired as Yt, ManageCustomTokenContentProps as Z, getErc20BalanceQueryKey as Za, useSendTokenModal as Zi, useScrollToTop as Zn, DisconnectConfirmContent as Zo, randomTransactionUser as Zr, VthoPerGasAtSpeed as Zs, useUpgradeRequired as Zt, ModalNotificationButton as _, useIpfsMetadatas as _a, PrivyAppInfo as _c, getGenericDelegatorUrl as _i, useCurrentAccountImplementationVersion as _n, useUnsetDomain as _o, MultipleClausesCallParameters as _r, PasskeyLoginButton as _s, SelectTokenContent as _t, useModal as a, useTransactionModal as aa, TransactionSpeed as ac, DEFAULT_PRIVY_ECOSYSTEM_APPS as ai, getIsDeployedQueryKey as an, getB3trBalanceQueryKey as ao, useMultipleClausesCall as ar, TransactionModalContent as as, CustomizationSummaryContentProps as at, AccountAvatar as b, getIpfsImage as ba, TokenBalance as bc, fetchAppHubApps as bi, useAccountImplementationAddress as bn, useGetAvatarLegacy as bo, buildCallClauses as br, EcosystemButton as bs, ThorClient$1 as bt, LegalDocumentsModal as c, ConnectModalProvider as ca, CURRENCY as cc, SUPPORTED_GAS_TOKENS as ci, getHasV1SmartAccountQueryKey as cn, getCurrentAllocationsRoundIdQueryKey as co, getLocalStorageItem as cr, TransactionModalProps as cs, FAQContent as ct, UpgradeSmartAccountModalContentsTypes as d, useSwapTransaction as da, CrossAppConnectionCache as dc, TogglePassportCheck as di, useGetAccountVersion as dn, TokenWithValue as do, isBrowser as dr, WalletButtonProps as ds, ChooseNameSearchContent as dt, WalletModalProvider as ea, GasTokenEstimate as ec, humanAddress as ei, getSmartAccountQueryKey as en, getTokenInfo as eo, useFeatureAnnouncement as er, SettingsContent as es, UpgradeSmartAccountContent as et, UpgradeSmartAccountModalStyle as f, useSingleImageUpload as fa, ENSRecords as fc, VECHAIN_KIT_COOKIES_CONFIG as fi, getAccountAddress as fn, useTokensWithValues as fo, isOnline as fr, WalletDisplayVariant as fs, ChooseNameSearchContentProps as ft, GasFeeSummary as g, useUploadImages as ga, NFTMediaType as gc, getENV as gi, getCurrentAccountImplementationVersionQueryKey as gn, useTokenBalances as go, setLocalStorageItem as gr, DappKitButton as gs, ReceiveTokenContent as gt, GasFeeTokenSelector as h, imageCompressionOptions as ha, ExecuteWithAuthorizationSignData as hc, VECHAIN_PRIVY_APP_ID as hi, getCurrentAccountImplementationVersion as hn, WalletTokenBalance as ho, safeWindowOpen as hr, VeChainWithPrivyLoginButton as hs, SwapTokenContent as ht, ModalProvider as i, TransactionModalProvider as ia, GasTokenType as ic, DEFAULT_GAS_TOKEN_PREFERENCES as ii, getIsDeployed as in, useGetCustomTokenBalances as io, useCallClause as ir, TransactionToast as is, CustomizationSummaryContent as it, CrossAppConnectionSecurityCard as j, useXAppMetadata as ja, ProfileModalProvider as ji, estimateAndBuildTxBody as jn, useGetAvatar as jo, isRejectionError as jr, useVechainKitThemeConfig as js, buildVETClauses as jt, AddressDisplay as k, XAppMetadata as ka, useNotifications as ki, decodeRawTx as kn, useGetTextRecords as ko, removePrefix as kr, ColorModeSync as ks, BuildTransactionProps as kt, LegalDocumentsModalContentsTypes as l, useConnectModal as la, CURRENCY_SYMBOLS as lc, TOKEN_LOGOS as li, useHasV1SmartAccount as ln, useCurrentAllocationsRoundId as lo, getWindowOrigin as lr, SocialIcons as ls, ChooseNameSummaryContent as lt, LoginLoadingModal as m, compressImages as ma, ExecuteBatchWithAuthorizationSignData as mc, VECHAIN_KIT_TERMS_CONFIG as mi, useGetAccountAddress as mn, useTokenPrices as mo, safeQuerySelector as mr, LoginWithGithubButton as ms, ChooseNameContentProps as mt, getConfig as n, TransactionToastProvider as na, GasTokenPreferences as nc, humanNumber as ni, useRefreshSmartAccountQueries as nn, TokenWithBalance as no, getCallClauseQueryKey as nr, AccessAndSecurityContent as ns, ProfileContent as nt, DAppKitWalletButton as o, AccountModalProvider as oa, ENS_TEXT_RECORDS as oc, ENV as oi, useIsSmartAccountDeployed as on, useGetB3trBalance as oo, copyToClipboard as or, ShareButtons as os, AccountCustomizationContentProps as ot, EcosystemModal as p, UploadedImage as pa, EnhancedClause as pc, VECHAIN_KIT_STORAGE_KEYS as pi, getAccountAddressQueryKey as pn, ExchangeRates as po, removeLocalStorageItem as pr, ConnectPopover as ps, ChooseNameContent as pt, ChangeCurrencyContent as q, SupportedToken as qa, useAccessAndSecurityModal as qi, UseEventsParams as qn, useFetchPrivyStatus as qo, compareListOfAddresses as qr, EstimatedGas as qs, getUpgradeRequiredForAccountQueryKey as qt, AccountModalOptions as r, useTransactionToast as ra, GasTokenSelection as rc, isZero as ri, useRefreshFactoryQueries as rn, getCustomTokenBalanceQueryKey as ro, getCallClauseQueryKeyWithArgs as rr, AccountMainContent as rs, ProfileContentProps as rt, LegalDocumentItem as s, useAccountModal as sa, TextRecords as sc, PrivyEcosystemApp as si, getHasV1SmartAccount as sn, useCustomTokens as so, getDocumentTitle as sr, TransactionModal as ss, CustomizationContent as st, AppConfig as t, useWalletModal as ta, GasTokenInfo as tc, humanDomain as ti, useSmartAccount as tn, useGetCustomTokenInfo as to, useCurrency as tr, SettingsContentProps as ts, UpgradeSmartAccountContentProps as tt, UpgradeSmartAccountModal as u, useSwapQuotes as ua, ConnectionSource as uc, TOKEN_LOGO_COMPONENTS as ui, getAccountVersionQueryKey as un, useTotalBalance as uo, hasNavigator as ur, WalletButton as us, ChooseNameSummaryContentProps as ut, TransactionButtonAndStatus as v, IpfsImage as va, PrivyLoginMethod as vc, notFoundImage as vi, getAccountImplementationAddress as vn, getAvatarLegacy as vo, MultipleClausesCallReturnType as vr, LoginWithGoogleButton as vs, SendTokenSummaryContent as vt, AssetButton as w, getIpfsMetadata as wa, Wallet as wc, useLoginWithOAuth as wi, UseEstimateAllTokensParams as wn, useGetResolverAddress as wo, addPrefix as wr, MainContent as ws, usePrivy as wt, ScrollToTopWrapper as x, getIpfsImageQueryKey as xa, TransactionStatus as xc, getAppHubAppsQueryKey as xi, getAccountBalance as xn, getAvatarOfAddressQueryKey as xo, executeCallClause as xr, VeChainLoginButton as xs, useDAppKitWallet as xt, TransactionButtonAndStatusProps as y, MAX_IMAGE_SIZE as ya, SmartAccount as yc, AppHubApp as yi, getAccountImplementationAddressQueryKey as yn, getAvatarLegacyQueryKey as yo, ViewFunctionResult as yr, PrivyButton as ys, SendTokenContent as yt, AccountDetailsButton as z, MostVotedAppsInRoundReturnType as za, useAccountCustomizationModal as zi, useSyncableLocalStorage as zn, buildVetDomainClauses as zo, gmNfts as zr, VechainKitProviderProps as zs, getEventLogs as zt };
+//# sourceMappingURL=index-ur27qfX4.d.cts.map