@vechain/vechain-kit 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,1483 @@
+import { BoxProps, IconProps, ImageProps, IconButtonProps, StackProps } from '@chakra-ui/react';
+export { useColorMode as useDAppKitPrivyColorMode } from '@chakra-ui/react';
+import * as React$1 from 'react';
+import React__default, { ReactElement, ReactNode, ElementType } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { IconType } from 'react-icons';
+import { User, ConnectedWallet, WalletListEntry } from '@privy-io/react-auth';
+export { useCrossAppAccounts, usePrivy } from '@privy-io/react-auth';
+import { DAppKitUIOptions } from '@vechain/dapp-kit-react';
+export { useConnex } from '@vechain/dapp-kit-react';
+import { ThorClient } from '@vechain/sdk-network';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as abitype from 'abitype';
+import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/types/authorization';
+import * as viem from 'viem';
+import * as viem_accounts from 'viem/accounts';
+
+declare const SimpleAccountABI: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "target";
+        readonly type: "address";
+    }];
+    readonly name: "AddressEmptyCode";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ECDSAInvalidSignature";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "length";
+        readonly type: "uint256";
+    }];
+    readonly name: "ECDSAInvalidSignatureLength";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ECDSAInvalidSignatureS";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "implementation";
+        readonly type: "address";
+    }];
+    readonly name: "ERC1967InvalidImplementation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ERC1967NonPayable";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "FailedCall";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidInitialization";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitializing";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UUPSUnauthorizedCallContext";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "slot";
+        readonly type: "bytes32";
+    }];
+    readonly name: "UUPSUnsupportedProxiableUUID";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [];
+    readonly name: "EIP712DomainChanged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "version";
+        readonly type: "uint64";
+    }];
+    readonly name: "Initialized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "SimpleAccountInitialized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "implementation";
+        readonly type: "address";
+    }];
+    readonly name: "Upgraded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UPGRADE_INTERFACE_VERSION";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "eip712Domain";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes1";
+        readonly name: "fields";
+        readonly type: "bytes1";
+    }, {
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "verifyingContract";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "extensions";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "dest";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "func";
+        readonly type: "bytes";
+    }];
+    readonly name: "execute";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "dest";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "func";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "executeBatch";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "executeWithAuthorization";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "anOwner";
+        readonly type: "address";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "onERC1155BatchReceived";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "onERC1155Received";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "onERC721Received";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "proxiableUUID";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newImplementation";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "upgradeToAndCall";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
+}];
+declare const SimpleAccountFactoryABI: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "AccessControlBadConfirmation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "neededRole";
+        readonly type: "bytes32";
+    }];
+    readonly name: "AccessControlUnauthorizedAccount";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "target";
+        readonly type: "address";
+    }];
+    readonly name: "AddressEmptyCode";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "implementation";
+        readonly type: "address";
+    }];
+    readonly name: "ERC1967InvalidImplementation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ERC1967NonPayable";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "FailedCall";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidInitialization";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitializing";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UUPSUnauthorizedCallContext";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "slot";
+        readonly type: "bytes32";
+    }];
+    readonly name: "UUPSUnsupportedProxiableUUID";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "contract SimpleAccount";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "salt";
+        readonly type: "uint256";
+    }];
+    readonly name: "AccountCreated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "version";
+        readonly type: "uint64";
+    }];
+    readonly name: "Initialized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "previousAdminRole";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "newAdminRole";
+        readonly type: "bytes32";
+    }];
+    readonly name: "RoleAdminChanged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly name: "RoleGranted";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly name: "RoleRevoked";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "implementation";
+        readonly type: "address";
+    }];
+    readonly name: "Upgraded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "DEFAULT_ADMIN_ROLE";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UPGRADE_INTERFACE_VERSION";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "accountImplementation";
+    readonly outputs: readonly [{
+        readonly internalType: "contract SimpleAccount";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "createAccount";
+    readonly outputs: readonly [{
+        readonly internalType: "contract SimpleAccount";
+        readonly name: "ret";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "getAccountAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getRoleAdmin";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "grantRole";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "hasRole";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "proxiableUUID";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "callerConfirmation";
+        readonly type: "address";
+    }];
+    readonly name: "renounceRole";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "role";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "revokeRole";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newImplementation";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "upgradeToAndCall";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}];
+
+type Props$q = {
+    boxSize?: string | number;
+} & Omit<BoxProps, 'dangerouslySetInnerHTML'>;
+declare const GoogleLogo: React__default.FC<Props$q>;
+
+type Props$p = {
+    isDark?: boolean;
+    boxSize?: string | number;
+} & Omit<BoxProps, 'dangerouslySetInnerHTML'>;
+declare const TwitterLogo: React__default.FC<Props$p>;
+
+type Props$o = {
+    isDark?: boolean;
+} & Omit<IconProps, 'dangerouslySetInnerHTML'>;
+declare const VechainLogo: React__default.FC<Props$o>;
+
+type Props$n = {
+    isDark?: boolean;
+} & Omit<ImageProps, 'dangerouslySetInnerHTML'>;
+declare const VechainLogoHorizontal: React__default.FC<Props$n>;
+
+type Props$m = {
+    isOpen: boolean;
+    onClose: () => void;
+    logo?: string;
+};
+type ConnectModalContents = 'main' | 'ecosystem' | 'email-verification';
+declare const ConnectModal: ({ isOpen, onClose, logo }: Props$m) => react_jsx_runtime.JSX.Element;
+
+type Props$l = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<ConnectModalContents>>;
+    onClose: () => void;
+};
+declare const EcosystemContent: ({ setCurrentContent, onClose }: Props$l) => react_jsx_runtime.JSX.Element;
+
+type Props$k = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<ConnectModalContents>>;
+    onClose: () => void;
+    logo?: string;
+};
+declare const MainContent: ({ setCurrentContent, onClose, logo }: Props$k) => react_jsx_runtime.JSX.Element;
+
+interface ConnectionButtonProps {
+    isDark: boolean;
+    onClick: () => void;
+    text?: string;
+    leftIcon?: ReactElement;
+    icon?: IconType;
+}
+declare const ConnectionButton: ({ isDark, onClick, leftIcon, text, icon, }: ConnectionButtonProps) => react_jsx_runtime.JSX.Element | null;
+
+declare const EmailLoginButton: () => react_jsx_runtime.JSX.Element;
+
+declare const WalletButton: () => react_jsx_runtime.JSX.Element;
+
+type TransactionModalProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    status: string;
+    pendingTitle?: ReactNode;
+    confirmationTitle?: ReactNode;
+    errorTitle?: ReactNode;
+    errorDescription?: string;
+    successTitle?: ReactNode;
+    showSocialButtons?: boolean;
+    socialDescriptionEncoded?: string;
+    showTryAgainButton?: boolean;
+    onTryAgain?: () => void;
+    showExplorerButton?: boolean;
+    txId?: string;
+};
+declare const TransactionModal: ({ isOpen, onClose, status, pendingTitle, confirmationTitle, errorTitle, errorDescription, successTitle, showSocialButtons, socialDescriptionEncoded, showTryAgainButton, onTryAgain, showExplorerButton, txId, }: TransactionModalProps) => react_jsx_runtime.JSX.Element | null;
+
+/**
+ * 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;
+        }[];
+    };
+    primaryType: string;
+    message: {
+        validAfter: number;
+        validBefore: number;
+        to: string | null | undefined;
+        value: string;
+        data: 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 = Connex.VM.Clause & {
+    comment?: string;
+    abi?: object;
+};
+type PrivyAppInfo$1 = {
+    name: string;
+    logo_url: string;
+    description?: string;
+};
+type SocialInfo = {
+    code: string;
+    name: string;
+    logo_url: string;
+    description?: string;
+};
+type PrivyLoginMethod = 'wallet' | 'email' | 'sms' | 'google' | 'twitter' | 'discord' | 'github' | 'linkedin' | 'spotify' | 'instagram' | 'tiktok' | 'apple' | 'farcaster' | 'telegram';
+
+/**
+ * Network URL.
+ * Defaults to mainnet.
+ */
+declare const NETWORK_URL: string;
+/**
+ * Thor client instance
+ */
+declare const THOR_CLIENT: ThorClient;
+/**
+ * Delegator url for the account abstraction factory contract
+ */
+declare const DELEGATOR_URL: string;
+
+declare const ACCOUNT_FACTORY_ADDRESSES: {
+    readonly '14018334920824264832118464179726739019961432051877733167310318607178': "0xC06Ad8573022e2BE416CA89DA47E8c592971679A";
+    readonly '1176455790972829965191905223412607679856028701100105089447013101863': "0x7EABA81B4F3741Ac381af7e025f3B6e0428F05Fb";
+};
+declare const TOKEN_LOGOS: Record<string, string>;
+declare const EXPLORER_URL: {
+    readonly '14018334920824264832118464179726739019961432051877733167310318607178': "https://vechainstats.com/transaction";
+    readonly '1176455790972829965191905223412607679856028701100105089447013101863': "https://explore-testnet.vechain.org/transactions";
+};
+declare const VECHAIN_PRIVY_APP_ID = "cm4wxxujb022fyujl7g0thb21";
+declare const WALLET_INFOS: SocialInfo[];
+declare const SOCIAL_INFOS: SocialInfo[];
+
+declare const humanAddress: (address: string, charAtStart?: number, charAtEnd?: number) => string;
+declare const humanDomain: (domain: string, lengthBefore?: number, lengthAfter?: number) => string;
+declare const getPicassoImage: (address: string, base64?: boolean) => string;
+
+declare const randomTransactionUser: {
+    privateKey: `0x${string}`;
+    account: {
+        address: viem_accounts.Address;
+        nonceManager?: viem_accounts.NonceManager | undefined;
+        sign: (parameters: {
+            hash: viem.Hash;
+        }) => Promise<viem.Hex>;
+        experimental_signAuthorization: (parameters: viem__types_experimental_eip7702_types_authorization.Authorization) => Promise<viem_accounts.SignAuthorizationReturnType>;
+        signMessage: ({ message }: {
+            message: viem.SignableMessage;
+        }) => Promise<viem.Hex>;
+        signTransaction: <serializer extends viem.SerializeTransactionFn<viem.TransactionSerializable> = viem.SerializeTransactionFn<viem.TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<viem.IsNarrowable<viem.TransactionSerialized<viem.GetTransactionType<transaction>>, viem.Hex> extends true ? viem.TransactionSerialized<viem.GetTransactionType<transaction>> : viem.Hex>;
+        signTypedData: <const typedData extends abitype.TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: viem.TypedDataDefinition<typedData, primaryType>) => Promise<viem.Hex>;
+        publicKey: viem.Hex;
+        source: "privateKey";
+        type: "local";
+    };
+    address: string;
+};
+
+/**
+ * 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: (addr: string | undefined | null) => boolean;
+declare const leftPadWithZeros: (str: string, length: number) => string;
+
+type TransactionToastProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    status: string;
+    txReceipt: any;
+    resetStatus: () => void;
+    error?: TransactionStatusErrorType;
+};
+declare const TransactionToast: ({ isOpen, onClose, status, txReceipt, error, resetStatus, }: TransactionToastProps) => react_jsx_runtime.JSX.Element | null;
+
+type Props$j = {
+    isOpen: boolean;
+    onClose: () => void;
+};
+declare const AccountModal: ({ isOpen, onClose }: Props$j) => react_jsx_runtime.JSX.Element;
+
+type Wallet = {
+    address: string;
+    domain: string | undefined;
+    image: string;
+};
+type SmartAccount = Wallet & {
+    isDeployed: boolean;
+    owner: string;
+};
+type ConnectionSource = {
+    type: 'privy' | 'wallet' | 'privy-cross-app';
+    displayName: string;
+};
+type UseWalletReturnType = {
+    wallet: Wallet;
+    embeddedWallet: Wallet;
+    crossAppWallet: Wallet;
+    smartAccount: SmartAccount;
+    selectedAccount: Wallet;
+    connectedWallet: Wallet;
+    privyUser: User | null;
+    connection: {
+        isConnected: boolean;
+        isConnectedWithPrivy: boolean;
+        isConnectedWithDappKit: boolean;
+        isConnectedWithCrossAppPrivy: boolean;
+        isLoadingPrivyConnection: boolean;
+        source: ConnectionSource;
+        isInAppBrowser: boolean;
+    };
+    disconnect: () => Promise<void>;
+};
+declare const useWallet: () => UseWalletReturnType;
+
+/**
+ * Poll the chain for a transaction receipt until it is found (or timeout after 5 blocks)
+ * @param thor Thor instance
+ * @param id Transaction id
+ * @param blocksTimeout Number of blocks to wait for the receipt
+ * @returns Transaction receipt
+ */
+declare const pollForReceipt: (thor: Connex.Thor, id?: string, blocksTimeout?: number) => Promise<Connex.Thor.Transaction.Receipt>;
+/**
+ * Get the tx receipt of a tx id with a block timeout to wait for the receipt
+ * @param txId The tx id to get the receipt
+ * @param blockTimeout The block timeout to wait for the receipt
+ * @returns The tx receipt
+ */
+declare const useTxReceipt: (txId?: string, blockTimeout?: number) => {
+    data: Connex.Thor.Transaction.Receipt | null | undefined;
+    error: Error | null;
+    isLoading: boolean;
+};
+
+interface SmartAccountContextType {
+    address: string | undefined;
+    owner: string | undefined;
+    embeddedWallet: ConnectedWallet | undefined;
+    isDeployed: boolean;
+    sendTransaction: (tx: {
+        txClauses: Connex.VM.Clause[];
+        title?: string;
+        description?: string;
+        buttonText?: string;
+    }) => Promise<string>;
+    exportWallet: () => Promise<void>;
+    thor: ThorClient;
+    nodeUrl: string;
+    delegatorUrl: string;
+    accountFactory: string;
+    delegateAllTransactions: boolean;
+    chainId: string;
+}
+/**
+ * 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 SmartAccountProvider: ({ children, nodeUrl, delegatorUrl, delegateAllTransactions, }: {
+    children: React__default.ReactNode;
+    nodeUrl: string;
+    delegatorUrl: string;
+    delegateAllTransactions: boolean;
+}) => react_jsx_runtime.JSX.Element;
+declare const useSmartAccount: () => SmartAccountContextType;
+
+interface SmartAccountAddressResult {
+    address: string | undefined;
+}
+declare const getSmartAccountAddress: (ownerAddress?: string) => Promise<SmartAccountAddressResult>;
+declare const getSmartAccountAddressQueryKey: (ownerAddress?: string) => (string | undefined)[];
+/**
+ * Hook to get the smart account address for a given owner address
+ * @param ownerAddress The address of the smart account owner
+ * @returns The smart account address and loading/error states
+ */
+declare const useGetSmartAccountAddress: (ownerAddress?: string) => _tanstack_react_query.UseQueryResult<SmartAccountAddressResult, Error>;
+
+declare const getAccountBalance: (thor: Connex.Thor, 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_query.UseQueryResult<{
+    balance: string;
+    energy: string;
+}, Error>;
+
+declare const PRICE_FEED_IDS: {
+    readonly B3TR: "0x623374722d757364000000000000000000000000000000000000000000000000";
+    readonly VET: "0x7665742d75736400000000000000000000000000000000000000000000000000";
+    readonly VTHO: "0x7674686f2d757364000000000000000000000000000000000000000000000000";
+};
+type SupportedToken = keyof typeof PRICE_FEED_IDS;
+declare const getTokenUsdPrice: (thor: Connex.Thor, token: SupportedToken) => Promise<number>;
+declare const getTokenUsdPriceQueryKey: (token: SupportedToken) => string[];
+declare const useGetTokenUsdPrice: (token: SupportedToken) => _tanstack_react_query.UseQueryResult<number, Error>;
+
+declare const getB3trBalance: (thor: Connex.Thor, address?: string) => Promise<string>;
+declare const getB3trBalanceQueryKey: (address?: string) => (string | undefined)[];
+declare const useGetB3trBalance: (address?: string) => _tanstack_react_query.UseQueryResult<string, Error>;
+
+declare const getVot3Balance: (thor: Connex.Thor, address?: string) => Promise<string>;
+declare const getVot3BalanceQueryKey: (address?: string) => (string | undefined)[];
+declare const useGetVot3Balance: (address?: string) => _tanstack_react_query.UseQueryResult<string, Error>;
+
+declare const useBalances: () => {
+    isLoading: boolean;
+    balances: {
+        vet: number;
+        vtho: number;
+        b3tr: number;
+        vot3: number;
+        veDelegate: number;
+    };
+    prices: {
+        vet: number;
+        vtho: number;
+        b3tr: number;
+    };
+    totalBalance: number;
+};
+
+declare const getVeDelegateBalance: (thor: Connex.Thor, address?: string) => Promise<string>;
+declare const getVeDelegateBalanceQueryKey: (address?: string) => (string | undefined)[];
+declare const useGetVeDelegateBalance: (address?: string) => _tanstack_react_query.UseQueryResult<string, Error>;
+
+interface 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;
+}
+declare const fetchPrivyAppInfo: (appId: string) => Promise<PrivyAppInfo>;
+declare const getPrivyAppInfoQueryKey: (appIds: string | string[]) => string[];
+declare const useFetchAppInfo: (appIds: string | string[]) => _tanstack_react_query.UseQueryResult<{
+    [k: string]: PrivyAppInfo;
+}, Error>;
+
+interface VeChainDomainResult$1 {
+    address?: string;
+    domain?: string;
+    isValidAddressOrDomain: boolean;
+    isLoading: boolean;
+}
+declare const getVetDomainQueryKey: (addressOrDomain: string) => string[];
+declare const useGetVetDomain: (addressOrDomain: string) => _tanstack_react_query.UseQueryResult<VeChainDomainResult$1, Error>;
+
+interface VeChainDomainResult {
+    address?: string;
+    domain?: string;
+    isValidAddressOrDomain: boolean;
+    isLoading: boolean;
+}
+interface CachedVeChainDomainResult {
+    domainResult: VeChainDomainResult;
+    getCachedDomain: () => string | null;
+    saveCachedDomain: (domain: string) => void;
+}
+declare const useCachedVeChainDomain: (address: string) => CachedVeChainDomainResult;
+
+declare const useConnectModal: () => {
+    open: () => void;
+    close: () => void;
+    isOpen: boolean;
+};
+declare const ConnectModalProvider: ({ children }: {
+    children: ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const useAccountModal: () => {
+    open: () => void;
+    close: () => void;
+    isOpen: boolean;
+};
+declare const AccountModalProvider: ({ children }: {
+    children: ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+/**
+ * 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
+ */
+type UseSendTransactionProps = {
+    signerAccountAddress?: string | null;
+    clauses?: EnhancedClause[] | (() => EnhancedClause[]) | (() => Promise<EnhancedClause[]>);
+    onTxConfirmed?: () => void | Promise<void>;
+    onTxFailedOrCancelled?: () => void | Promise<void>;
+    suggestedMaxGas?: number;
+    privyUIOptions?: {
+        title?: string;
+        description?: string;
+        buttonText?: string;
+    };
+};
+/**
+ * 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 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?: EnhancedClause[]) => Promise<void>;
+    isTransactionPending: boolean;
+    txReceipt: Connex.Thor.Transaction.Receipt | null;
+    status: TransactionStatus;
+    resetStatus: () => void;
+    error?: TransactionStatusErrorType;
+};
+/**
+ * Generic hook to send a transaction using connex.
+ * 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).
+ *
+ * @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
+ * @returns see {@link UseSendTransactionReturnValue}
+ */
+declare const useSendTransaction: ({ signerAccountAddress, clauses, onTxConfirmed, onTxFailedOrCancelled, suggestedMaxGas, privyUIOptions, }: UseSendTransactionProps) => UseSendTransactionReturnValue;
+
+type useTransferERC20Props = {
+    fromAddress: string;
+    receiverAddress: string;
+    amount: string;
+    tokenAddress: string;
+    tokenName: string;
+    onSuccess?: () => void;
+    onSuccessMessageTitle?: number;
+};
+type useTransferERC20ReturnValue = {
+    sendTransaction: () => Promise<void>;
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const useTransferERC20: ({ fromAddress, receiverAddress, amount, tokenAddress, tokenName, onSuccess, }: useTransferERC20Props) => useTransferERC20ReturnValue;
+
+type useTransferVETProps = {
+    fromAddress: string;
+    receiverAddress: string;
+    amount: string;
+    onSuccess?: () => void;
+};
+type useTransferVETReturnValue = {
+    sendTransaction: () => Promise<void>;
+} & Omit<UseSendTransactionReturnValue, 'sendTransaction'>;
+declare const useTransferVET: ({ fromAddress, receiverAddress, amount, onSuccess, }: useTransferVETProps) => useTransferVETReturnValue;
+
+declare const useRefreshBalances: () => {
+    refresh: () => Promise<void>;
+};
+
+type AccountModalContentTypes = 'main' | 'settings' | 'smart-account' | 'accounts' | 'send-token' | 'receive-token' | {
+    type: 'send-token-summary';
+    props: {
+        toAddressOrDomain: string;
+        resolvedDomain?: string;
+        resolvedAddress?: string;
+        amount: string;
+        selectedToken: {
+            symbol: string;
+            balance: string;
+            address: string;
+            numericBalance: number;
+            price: number;
+        };
+        onSend: (address: string, amount: string) => void;
+        setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    };
+};
+
+type Props$i = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    onClose: () => void;
+    wallet: Wallet;
+};
+declare const AccountMainContent: ({ setCurrentContent, wallet }: Props$i) => react_jsx_runtime.JSX.Element;
+
+type Props$h = {
+    setCurrentContent: React__default.Dispatch<React__default.SetStateAction<AccountModalContentTypes>>;
+    onClose: () => void;
+    wallet?: Wallet;
+};
+declare const AccountsListContent: ({ setCurrentContent, onClose }: Props$h) => react_jsx_runtime.JSX.Element;
+
+type Props$g = {
+    setCurrentContent: React__default.Dispatch<React__default.SetStateAction<AccountModalContentTypes>>;
+};
+declare const SmartAccountContent: ({ setCurrentContent }: Props$g) => react_jsx_runtime.JSX.Element;
+
+type Props$f = {
+    setCurrentContent: (content: AccountModalContentTypes) => void;
+    onLogoutSuccess: () => void;
+};
+declare const WalletSettingsContent: ({ setCurrentContent, onLogoutSuccess, }: Props$f) => react_jsx_runtime.JSX.Element;
+
+type Props$e = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    onSend: (address: string, amount: string) => void;
+};
+declare const SendTokenContent: ({ setCurrentContent, onSend }: Props$e) => react_jsx_runtime.JSX.Element;
+
+type Props$d = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    onSend: (address: string, amount: string) => void;
+    toAddressOrDomain: string;
+    resolvedDomain?: string;
+    resolvedAddress?: string;
+    amount: string;
+    selectedToken: {
+        symbol: string;
+        balance: string;
+        address: string;
+        numericBalance: number;
+        price: number;
+    };
+};
+declare const SendTokenSummaryContent: ({ setCurrentContent, toAddressOrDomain, resolvedDomain, resolvedAddress, amount, selectedToken, }: Props$d) => react_jsx_runtime.JSX.Element;
+
+type Token = {
+    symbol: string;
+    balance: string;
+    address: string;
+    numericBalance: number;
+    price: number;
+};
+type Props$c = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+    onSelectToken: (token: Token) => void;
+    onBack: () => void;
+};
+declare const SelectTokenContent: ({ onSelectToken, onBack }: Props$c) => react_jsx_runtime.JSX.Element;
+
+type Props$b = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const ReceiveTokenContent: ({ setCurrentContent }: Props$b) => react_jsx_runtime.JSX.Element;
+
+interface AccountDetailsButtonProps {
+    title: string;
+    address: string;
+    onClick: () => void;
+    leftIcon?: ElementType;
+    rightIcon?: ElementType;
+    leftImage?: string;
+    backgroundColor?: string;
+    border?: string;
+    isActive?: boolean;
+}
+declare const AccountDetailsButton: ({ leftIcon, rightIcon, title, address, onClick, leftImage, isActive, }: AccountDetailsButtonProps) => react_jsx_runtime.JSX.Element;
+
+interface ActionButtonProps {
+    title: string;
+    description: string;
+    onClick: () => void;
+    leftIcon?: ElementType;
+    rightIcon?: ElementType;
+    leftImage?: string;
+    backgroundColor?: string;
+    border?: string;
+    hide?: boolean;
+    showComingSoon?: boolean;
+}
+declare const ActionButton: ({ leftIcon, rightIcon, title, description, onClick, leftImage, hide, showComingSoon, backgroundColor, }: ActionButtonProps) => react_jsx_runtime.JSX.Element;
+
+type Props$a = {
+    wallet: Wallet;
+    size?: string;
+    onClick?: () => void;
+};
+declare const AccountSelector: ({ wallet, size, onClick }: Props$a) => react_jsx_runtime.JSX.Element;
+
+declare const BalanceSection: ({ mb }: {
+    mb?: number;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const AssetsSection: () => react_jsx_runtime.JSX.Element;
+
+type Props$9 = {
+    setCurrentContent: React.Dispatch<React.SetStateAction<AccountModalContentTypes>>;
+};
+declare const QuickActionsSection: ({ setCurrentContent }: Props$9) => react_jsx_runtime.JSX.Element;
+
+type Props$8 = {
+    children: ReactNode;
+};
+declare const FadeInView: ({ children }: Props$8) => react_jsx_runtime.JSX.Element;
+
+type Props$7 = {
+    children: ReactNode;
+};
+declare const FadeInViewFromBottom: ({ children }: Props$7) => react_jsx_runtime.JSX.Element;
+
+type Props$6 = {
+    children: ReactNode;
+};
+declare const FadeInViewFromLeft: ({ children }: Props$6) => react_jsx_runtime.JSX.Element;
+
+type Props$5 = {
+    children: ReactNode;
+};
+declare const FadeInViewFromRight: ({ children }: Props$5) => react_jsx_runtime.JSX.Element;
+
+type BackButtonProps = {
+    onClick: () => void;
+} & Partial<IconButtonProps>;
+declare const ModalBackButton: ({ onClick, ...props }: BackButtonProps) => react_jsx_runtime.JSX.Element;
+
+type Props$4 = {
+    wallet: Wallet;
+    label?: string;
+    size?: string;
+};
+declare const AddressDisplay: ({ wallet, label, size }: Props$4) => react_jsx_runtime.JSX.Element;
+
+type Props$3 = {} & Omit<StackProps, 'dangerouslySetInnerHTML'>;
+declare const VersionFooter: ({ ...props }: Props$3) => react_jsx_runtime.JSX.Element;
+
+type Props$2 = {
+    children: React.ReactNode;
+};
+declare const StickyHeaderContainer: ({ children }: Props$2) => react_jsx_runtime.JSX.Element;
+
+type Props$1 = {
+    children: React.ReactNode;
+};
+declare const StickyFooterContainer: ({ children }: Props$1) => react_jsx_runtime.JSX.Element;
+
+type LoginLoadingModalProps = {
+    isOpen: boolean;
+    onClose: () => void;
+};
+declare const LoginLoadingModal: ({ isOpen, onClose, }: LoginLoadingModalProps) => react_jsx_runtime.JSX.Element;
+
+type Props = {
+    children: ReactNode;
+    privyConfig: {
+        appId: string;
+        clientId: string;
+        appearance: {
+            walletList: WalletListEntry[];
+            theme: 'dark' | 'light';
+            accentColor: `#${string}`;
+            loginMessage: string;
+            logo: string;
+        };
+        embeddedWallets?: {
+            createOnLogin: 'users-without-wallets' | 'all-users' | 'off';
+        };
+        loginMethods: PrivyLoginMethod[];
+        ecosystemAppsID?: string[];
+        allowPasskeyLinking?: boolean;
+    };
+    feeDelegationConfig: {
+        delegatorUrl: string;
+        delegateAllTransactions: boolean;
+    };
+    dappKitConfig: DAppKitUIOptions;
+};
+type DAppKitPrivyConfig = {
+    privyConfig: Props['privyConfig'];
+    feeDelegationConfig: Props['feeDelegationConfig'];
+    dappKitConfig: Props['dappKitConfig'];
+    openConnectModal: () => void;
+    closeConnectModal: () => void;
+    isConnectModalOpen: boolean;
+    openAccountModal: () => void;
+    closeAccountModal: () => void;
+    isAccountModalOpen: boolean;
+};
+/**
+ * Context to store the Privy and DAppKit configs so that they can be used by the hooks/components
+ */
+declare const DAppKitPrivyContext: React$1.Context<DAppKitPrivyConfig | null>;
+/**
+ * Hook to get the Privy and DAppKit configs
+ */
+declare const useDAppKitPrivyConfig: () => DAppKitPrivyConfig;
+/**
+ * Provider to wrap the application with Privy and DAppKit
+ */
+declare const DAppKitPrivyProvider: ({ children, privyConfig, feeDelegationConfig, dappKitConfig, }: Omit<Props, "queryClient">) => react_jsx_runtime.JSX.Element;
+
+export { ACCOUNT_FACTORY_ADDRESSES, AccountDetailsButton, AccountMainContent, AccountModal, type AccountModalContentTypes, AccountModalProvider, AccountSelector, AccountsListContent, ActionButton, AddressDisplay, AssetsSection, BalanceSection, ConnectModal, type ConnectModalContents, ConnectModalProvider, ConnectionButton, type ConnectionSource, DAppKitPrivyContext, DAppKitPrivyProvider, DELEGATOR_URL, EXPLORER_URL, EcosystemContent, EmailLoginButton, type EnhancedClause, type ExecuteWithAuthorizationSignData, FadeInView, FadeInViewFromBottom, FadeInViewFromLeft, FadeInViewFromRight, GoogleLogo, LoginLoadingModal, MainContent, ModalBackButton, NETWORK_URL, PRICE_FEED_IDS, type PrivyAppInfo$1 as PrivyAppInfo, type PrivyLoginMethod, QuickActionsSection, ReceiveTokenContent, SOCIAL_INFOS, SelectTokenContent, SendTokenContent, SendTokenSummaryContent, SimpleAccountABI, SimpleAccountFactoryABI, type SmartAccount, SmartAccountContent, type SmartAccountContextType, SmartAccountProvider, type SocialInfo, StickyFooterContainer, StickyHeaderContainer, type SupportedToken, THOR_CLIENT, TOKEN_LOGOS, TransactionModal, type TransactionModalProps, type TransactionStatus, type TransactionStatusErrorType, TransactionToast, TwitterLogo, type UseSendTransactionReturnValue, type UseWalletReturnType, VECHAIN_PRIVY_APP_ID, VechainLogo, VechainLogoHorizontal, VersionFooter, WALLET_INFOS, type Wallet, WalletButton, WalletSettingsContent, compareAddresses, compareListOfAddresses, fetchPrivyAppInfo, getAccountBalance, getAccountBalanceQueryKey, getB3trBalance, getB3trBalanceQueryKey, getPicassoImage, getPrivyAppInfoQueryKey, getSmartAccountAddress, getSmartAccountAddressQueryKey, getTokenUsdPrice, getTokenUsdPriceQueryKey, getVeDelegateBalance, getVeDelegateBalanceQueryKey, getVetDomainQueryKey, getVot3Balance, getVot3BalanceQueryKey, humanAddress, humanDomain, isValidAddress, leftPadWithZeros, pollForReceipt, randomTransactionUser, regexPattern, useAccountBalance, useAccountModal, useBalances, useCachedVeChainDomain, useConnectModal, useDAppKitPrivyConfig, useFetchAppInfo, useGetB3trBalance, useGetSmartAccountAddress, useGetTokenUsdPrice, useGetVeDelegateBalance, useGetVetDomain, useGetVot3Balance, useRefreshBalances, useSendTransaction, useSmartAccount, useTransferERC20, useTransferVET, useTxReceipt, useWallet };