@reown/appkit 1.8.15-viem-upgrade.0 → 1.8.15-viem-upgrade-2.0

package/dist/types/src/library/vue/index.d.ts

@@ -0,0 +1,86 @@
+import type { ChainNamespace } from '@reown/appkit-common';
+import { type ConnectorType, type Event } from '@reown/appkit-controllers';
+import type { AppKitAccountButton, AppKitButton, AppKitConnectButton, AppKitNetworkButton, W3mAccountButton, W3mButton, W3mConnectButton, W3mNetworkButton } from '@reown/appkit-scaffold-ui';
+import type { AppKitBaseClient as AppKit, OpenOptions, Views } from '../../client/appkit-base-client.js';
+import type { AppKitOptions } from '../../utils/TypesUtil.js';
+export interface AppKitEvent {
+    timestamp: number;
+    data: Event;
+}
+type ThemeModeOptions = AppKitOptions['themeMode'];
+type ThemeVariablesOptions = AppKitOptions['themeVariables'];
+type UseAppKitReturnType<T> = {
+    walletProvider: T | undefined;
+    walletProviderType: ConnectorType | undefined;
+};
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        AppKitButton: Pick<AppKitButton, 'size' | 'label' | 'loadingLabel' | 'disabled' | 'balance' | 'namespace'>;
+        AppKitConnectButton: Pick<AppKitConnectButton, 'size' | 'label' | 'loadingLabel'>;
+        AppKitAccountButton: Pick<AppKitAccountButton, 'disabled' | 'balance'>;
+        AppKitNetworkButton: Pick<AppKitNetworkButton, 'disabled'>;
+        W3mConnectButton: Pick<W3mConnectButton, 'size' | 'label' | 'loadingLabel'>;
+        W3mAccountButton: Pick<W3mAccountButton, 'disabled' | 'balance'>;
+        W3mButton: Pick<W3mButton, 'size' | 'label' | 'loadingLabel' | 'disabled' | 'balance'>;
+        W3mNetworkButton: Pick<W3mNetworkButton, 'disabled'>;
+    }
+}
+export declare function getAppKit(appKit: AppKit): void;
+export * from '@reown/appkit-controllers/vue';
+export declare function useAppKitProvider<T>(chainNamespace: ChainNamespace): UseAppKitReturnType<T>;
+export declare function useAppKitTheme(): {
+    setThemeMode: (themeMode: ThemeModeOptions) => void;
+    setThemeVariables: (themeVariables: ThemeVariablesOptions) => void;
+    themeMode: import("@reown/appkit-controllers").ThemeMode;
+    themeVariables: {
+        '--w3m-font-family'?: string | undefined;
+        '--w3m-accent'?: string | undefined;
+        '--w3m-color-mix'?: string | undefined;
+        '--w3m-color-mix-strength'?: number | undefined;
+        '--w3m-font-size-master'?: string | undefined;
+        '--w3m-border-radius-master'?: string | undefined;
+        '--w3m-z-index'?: number | undefined;
+        '--w3m-qr-color'?: string | undefined;
+        '--apkt-font-family'?: string | undefined;
+        '--apkt-accent'?: string | undefined;
+        '--apkt-color-mix'?: string | undefined;
+        '--apkt-color-mix-strength'?: number | undefined;
+        '--apkt-font-size-master'?: string | undefined;
+        '--apkt-border-radius-master'?: string | undefined;
+        '--apkt-z-index'?: number | undefined;
+        '--apkt-qr-color'?: string | undefined;
+    };
+};
+export declare function useAppKit(): {
+    open: <View extends Views>(options?: OpenOptions<View>) => Promise<void | {
+        hash: string;
+    } | undefined>;
+    close: () => Promise<void>;
+};
+export declare function useWalletInfo(namespace?: ChainNamespace): {
+    walletInfo: {
+        [x: string]: unknown;
+        name: string;
+        icon?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+};
+export declare function useAppKitState(): {
+    open: boolean;
+    remoteFeatures: {
+        swaps?: import("@reown/appkit-common").SwapProvider[] | false | undefined;
+        email?: boolean | undefined;
+        socials?: import("@reown/appkit-controllers").SocialProvider[] | false | undefined;
+        activity?: boolean | undefined;
+        reownBranding?: boolean | undefined;
+        multiWallet?: boolean | undefined;
+        emailCapture?: import("@reown/appkit-controllers").EmailCaptureOptions[] | boolean | undefined;
+        reownAuthentication?: boolean | undefined;
+        payWithExchange?: boolean | undefined;
+        payments?: boolean | undefined;
+        onramp?: import("@reown/appkit-common").OnRampProvider[] | false | undefined;
+        headless?: boolean | undefined;
+    } | undefined;
+    selectedNetworkId: import("@reown/appkit-common").CaipNetworkId | undefined;
+};
+export declare function useAppKitEvents(): AppKitEvent;

package/dist/types/src/networks/bitcoin.d.ts

@@ -0,0 +1,177 @@
+export declare const bitcoin: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Bitcoin";
+    nativeCurrency: {
+        readonly name: "Bitcoin";
+        readonly symbol: "BTC";
+        readonly decimals: 8;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "000000000019d6689c085ae165831e93";
+    chainNamespace: "bip122";
+    caipNetworkId: "bip122:000000000019d6689c085ae165831e93";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+};
+export declare const bitcoinTestnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Bitcoin Testnet";
+    nativeCurrency: {
+        readonly name: "Bitcoin";
+        readonly symbol: "BTC";
+        readonly decimals: 8;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "000000000933ea01ad0ee984209779ba";
+    chainNamespace: "bip122";
+    caipNetworkId: "bip122:000000000933ea01ad0ee984209779ba";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+};
+export declare const bitcoinSignet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Bitcoin Signet";
+    nativeCurrency: {
+        readonly name: "Bitcoin";
+        readonly symbol: "BTC";
+        readonly decimals: 8;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "00000008819873e925422c1ff0f99f7c";
+    chainNamespace: "bip122";
+    caipNetworkId: "bip122:00000008819873e925422c1ff0f99f7c";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+};

package/dist/types/src/networks/index.d.ts

@@ -0,0 +1,7 @@
+export * from 'viem/chains';
+export * from './solana/index.js';
+export * from './bitcoin.js';
+export * from './ton/index.js';
+export * from './utils.js';
+export type { AppKitNetwork, ChainNamespace } from '@reown/appkit-common';
+export { AVAILABLE_NAMESPACES } from '@reown/appkit-common';

package/dist/types/src/networks/solana/index.d.ts

@@ -0,0 +1,3 @@
+export * from './solana.js';
+export * from './solanaDevnet.js';
+export * from './solanaTestnet.js';

package/dist/types/src/networks/solana/solana.d.ts

@@ -0,0 +1,55 @@
+export declare const solana: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Solana";
+    nativeCurrency: {
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    chainNamespace: "solana";
+    caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "solana-mainnet";
+    readonly deprecatedCaipNetworkId: "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ";
+};

package/dist/types/src/networks/solana/solanaDevnet.d.ts

@@ -0,0 +1,55 @@
+export declare const solanaDevnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Solana Devnet";
+    nativeCurrency: {
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    chainNamespace: "solana";
+    caipNetworkId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "solana-devnet";
+    readonly deprecatedCaipNetworkId: "solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K";
+};

package/dist/types/src/networks/solana/solanaTestnet.d.ts

@@ -0,0 +1,54 @@
+export declare const solanaTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Solana Testnet";
+    nativeCurrency: {
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+    chainNamespace: "solana";
+    caipNetworkId: "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "solana-testnet";
+};

package/dist/types/src/networks/ton/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ton.js';
+export * from './tonTestnet.js';

package/dist/types/src/networks/ton/ton.d.ts

@@ -0,0 +1,54 @@
+export declare const ton: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Tonscan";
+            readonly url: "https://tonscan.org";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "TON";
+    nativeCurrency: {
+        readonly name: "TON";
+        readonly symbol: "TON";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "-239";
+    chainNamespace: "ton";
+    caipNetworkId: "ton:-239";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "ton-mainnet";
+};

package/dist/types/src/networks/ton/tonTestnet.d.ts

@@ -0,0 +1,54 @@
+export declare const tonTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Tonscan";
+            readonly url: "https://testnet.tonscan.org";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "TON Testnet";
+    nativeCurrency: {
+        readonly name: "TON";
+        readonly symbol: "TON";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    id: "-3";
+    chainNamespace: "ton";
+    caipNetworkId: "ton:-3";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "ton-testnet";
+};

package/dist/types/src/networks/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Assign, ChainFormatters, Prettify } from 'viem';
+import type { CaipNetwork } from '@reown/appkit-common';
+export declare function defineChain<formatters extends ChainFormatters, const chain extends CaipNetwork<formatters>>(chain: chain): Prettify<Assign<CaipNetwork<undefined>, chain>>;

package/dist/types/src/universal-adapter/client.d.ts

@@ -0,0 +1,41 @@
+import type UniversalProvider from '@walletconnect/universal-provider';
+import { type ChainNamespace } from '@reown/appkit-common';
+import { AdapterBlueprint } from '@reown/appkit-controllers';
+export declare class UniversalAdapter extends AdapterBlueprint {
+    setUniversalProvider(universalProvider: UniversalProvider): Promise<void>;
+    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
+    disconnect(): Promise<{
+        connections: never[];
+    }>;
+    syncConnections(): Promise<void>;
+    getAccounts({ namespace }: AdapterBlueprint.GetAccountsParams & {
+        namespace: ChainNamespace;
+    }): Promise<AdapterBlueprint.GetAccountsResult>;
+    syncConnectors(): Promise<void>;
+    getBalance(params: AdapterBlueprint.GetBalanceParams): Promise<AdapterBlueprint.GetBalanceResult>;
+    signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
+    /**
+     *
+     * These methods are supported only on `wagmi` and `ethers` since the Solana SDK does not support them in the same way.
+     * These function definition is to have a type parity between the clients. Currently not in use.
+     */
+    estimateGas(): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
+    sendTransaction(): Promise<AdapterBlueprint.SendTransactionResult>;
+    walletGetAssets(_params: AdapterBlueprint.WalletGetAssetsParams): Promise<AdapterBlueprint.WalletGetAssetsResponse>;
+    writeContract(): Promise<AdapterBlueprint.WriteContractResult>;
+    emitFirstAvailableConnection(): void;
+    parseUnits(): AdapterBlueprint.ParseUnitsResult;
+    formatUnits(): AdapterBlueprint.FormatUnitsResult;
+    getCapabilities(): Promise<unknown>;
+    grantPermissions(): Promise<unknown>;
+    revokePermissions(): Promise<`0x${string}`>;
+    syncConnection(): Promise<{
+        id: string;
+        type: "WALLET_CONNECT";
+        chainId: number;
+        provider: UniversalProvider;
+        address: string;
+    }>;
+    switchNetwork(params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
+    getWalletConnectProvider(): UniversalProvider;
+}

package/dist/types/src/universal-adapter/index.d.ts

@@ -0,0 +1 @@
+export { UniversalAdapter } from './client.js';

package/dist/types/src/utils/BalanceUtil.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterBlueprint } from '@reown/appkit-controllers';
+import type { AppKit } from '../client/appkit.js';
+export declare function _internalFetchBalance(appKit: AppKit | undefined): Promise<{
+    data: AdapterBlueprint.GetBalanceResult | undefined;
+    error: string | null;
+    isSuccess: boolean;
+    isError: boolean;
+}>;
+export declare function updateBalance(appKit: AppKit): Promise<{
+    data: AdapterBlueprint.GetBalanceResult | undefined;
+    error: string | null;
+    isSuccess: boolean;
+    isError: boolean;
+}>;

package/dist/types/src/utils/ConfigUtil.d.ts

@@ -0,0 +1,29 @@
+import type { FeatureConfigMap, FeatureID, RemoteFeatures, TypedFeatureConfig } from '@reown/appkit-controllers';
+import type { AppKitOptionsWithSdk } from '../client/appkit-base-client.js';
+type FeatureKey = keyof FeatureConfigMap;
+export declare const ConfigUtil: {
+    localSettingsOverridden: Set<string>;
+    getApiConfig<T extends FeatureID>(id: T, apiProjectConfig: TypedFeatureConfig[] | null): Extract<import("@reown/appkit-controllers").BaseFeature<"activity", [] | null>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"onramp", "meld"[]>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"swap", "1inch"[]>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"social_login", ("email" | import("@reown/appkit-controllers").SocialProvider)[]>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"reown_branding", [] | null>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"multi_wallet", [] | null>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"email_capture", "required"[]>, {
+        id: T;
+    }> | Extract<import("@reown/appkit-controllers").BaseFeature<"headless", [] | null>, {
+        id: T;
+    }> | undefined;
+    addWarning(localFeatureValue: unknown, featureKey: FeatureKey): void;
+    processFeature<K extends FeatureKey>(featureKey: K, localFeatures: Record<string, unknown>, apiProjectConfig: TypedFeatureConfig[] | null, useApi: boolean, isBasic: boolean): FeatureConfigMap[K]["returnType"];
+    processApiFeature<K extends FeatureKey>(featureKey: K, apiConfig: TypedFeatureConfig): FeatureConfigMap[K]["returnType"];
+    processFallbackFeature<K extends FeatureKey>(featureKey: K, localValue: unknown): FeatureConfigMap[K]["returnType"];
+    fetchRemoteFeatures(config: AppKitOptionsWithSdk): Promise<RemoteFeatures>;
+};
+export {};