@ton/appkit 0.0.5-alpha.0 → 0.0.5-alpha.2

package/src/connectors/tonconnect/connectors/ton-connect-connector.ts

@@ -9,14 +9,12 @@
 import { TonConnectUI } from '@tonconnect/ui';
 import type { TonConnectUiCreateOptions } from '@tonconnect/ui';
 
-import type { Network } from '../../../types/network';
 import { TonConnectWalletAdapter } from '../adapters/ton-connect-wallet-adapter';
 import { CONNECTOR_EVENTS, NETWORKS_EVENTS } from '../../../core/app-kit';
 import type { Connector, ConnectorMetadata } from '../../../types/connector';
 import type { WalletInterface } from '../../../types/wallet';
-import type { AppKitEmitter } from '../../../core/app-kit';
 import { TONCONNECT_DEFAULT_CONNECTOR_ID } from '../constants/id';
-import type { AppKitNetworkManager } from '../../../core/network';
+import { createConnector } from '../../../types/connector';
 
 export interface TonConnectConnectorConfig {
     id?: string;
@@ -25,84 +23,121 @@ export interface TonConnectConnectorConfig {
     tonConnectUI?: TonConnectUI;
 }
 
-export class TonConnectConnector implements Connector {
-    readonly id: string;
-    readonly type = 'tonconnect';
-    readonly metadata: ConnectorMetadata;
-    readonly tonConnectUI: TonConnectUI;
-
-    private emitter: AppKitEmitter | null = null;
-    private unsubscribeTonConnect: (() => void) | null = null;
-
-    constructor(config: TonConnectConnectorConfig) {
-        if (config.tonConnectOptions && config.tonConnectUI) {
-            // eslint-disable-next-line no-console
-            console.warn(
-                'TonConnectConnector: both tonConnectOptions and tonConnectUI are provided, using tonConnectUI',
-            );
-        }
+export type TonConnectConnector = Connector & {
+    type: 'tonconnect';
+    tonConnectUI: TonConnectUI | null;
+};
 
-        this.id = config.id ?? TONCONNECT_DEFAULT_CONNECTOR_ID;
-        this.tonConnectUI = config?.tonConnectUI ?? new TonConnectUI(config.tonConnectOptions);
-        this.metadata = {
-            name: 'TonConnect',
-            iconUrl: 'https://avatars.githubusercontent.com/u/113980577',
-            ...config.metadata,
-        };
-    }
+export const createTonConnectConnector = (config: TonConnectConnectorConfig) => {
+    return createConnector(({ eventEmitter, networkManager, ssr }): TonConnectConnector => {
+        let originalTonConnectUI: TonConnectUI | null = null;
+        let unsubscribeTonConnect: (() => void) | null = null;
+
+        const id = config.id ?? TONCONNECT_DEFAULT_CONNECTOR_ID;
 
-    async initialize(emitter: AppKitEmitter, networkManager: AppKitNetworkManager): Promise<void> {
-        this.emitter = emitter;
+        function getTonConnectUI() {
+            if (originalTonConnectUI) {
+                return originalTonConnectUI;
+            }
 
-        // Subscribe to TonConnect status changes
-        this.unsubscribeTonConnect = this.tonConnectUI.onStatusChange((wallet) => {
-            const wallets = this.getConnectedWallets();
+            if (ssr && typeof window === 'undefined') {
+                return null;
+            }
 
-            if (wallet) {
-                this.emitter?.emit(CONNECTOR_EVENTS.CONNECTED, { wallets, connectorId: this.id }, this.id);
+            // check if we have pre-defined UI
+            if (config.tonConnectUI) {
+                originalTonConnectUI = config.tonConnectUI;
             } else {
-                this.emitter?.emit(CONNECTOR_EVENTS.DISCONNECTED, { connectorId: this.id }, this.id);
+                originalTonConnectUI = new TonConnectUI(config.tonConnectOptions);
+            }
+
+            setupListeners();
+
+            // restore connection
+            if (originalTonConnectUI) {
+                originalTonConnectUI.connector.restoreConnection();
             }
-        });
-
-        // Set default network and subscribe to changes
-        this.tonConnectUI.setConnectionNetwork(networkManager.getDefaultNetwork()?.chainId);
-        this.emitter?.on(NETWORKS_EVENTS.DEFAULT_CHANGED, ({ payload }) => {
-            this.tonConnectUI.setConnectionNetwork(payload.network?.chainId);
-        });
-
-        // Restore existing connection
-        await this.tonConnectUI.connector.restoreConnection();
-    }
-
-    destroy(): void {
-        this.unsubscribeTonConnect?.();
-        this.unsubscribeTonConnect = null;
-        this.emitter = null;
-    }
-
-    async connectWallet(network?: Network): Promise<void> {
-        this.tonConnectUI.setConnectionNetwork(network?.chainId);
-        await this.tonConnectUI.openModal();
-    }
-
-    async disconnectWallet(): Promise<void> {
-        await this.tonConnectUI.disconnect();
-    }
-
-    getConnectedWallets(): WalletInterface[] {
-        if (this.tonConnectUI.connected && this.tonConnectUI.wallet) {
-            const wallet = this.tonConnectUI.wallet;
-
-            const walletAdapter = new TonConnectWalletAdapter({
-                connectorId: this.id,
-                tonConnectWallet: wallet,
-                tonConnectUI: this.tonConnectUI,
+
+            return originalTonConnectUI;
+        }
+
+        function getConnectedWallets(): WalletInterface[] {
+            const ui = getTonConnectUI();
+
+            if (ui && ui.connected && ui.wallet) {
+                const wallet = ui.wallet;
+
+                return [
+                    new TonConnectWalletAdapter({
+                        connectorId: id,
+                        tonConnectWallet: wallet,
+                        tonConnectUI: ui,
+                    }),
+                ];
+            }
+
+            return [];
+        }
+
+        function setupListeners() {
+            if (!originalTonConnectUI || unsubscribeTonConnect) {
+                return;
+            }
+
+            unsubscribeTonConnect = originalTonConnectUI.onStatusChange((wallet) => {
+                const wallets = getConnectedWallets();
+
+                if (wallet) {
+                    eventEmitter.emit(CONNECTOR_EVENTS.CONNECTED, { wallets, connectorId: id }, id);
+                } else {
+                    eventEmitter.emit(CONNECTOR_EVENTS.DISCONNECTED, { connectorId: id }, id);
+                }
             });
 
-            return [walletAdapter];
+            // Set default network and subscribe to changes
+            originalTonConnectUI.setConnectionNetwork(networkManager.getDefaultNetwork()?.chainId);
+            eventEmitter.on(NETWORKS_EVENTS.DEFAULT_CHANGED, ({ payload }) => {
+                if (originalTonConnectUI) {
+                    originalTonConnectUI.setConnectionNetwork(payload.network?.chainId);
+                }
+            });
         }
 
-        return [];
-    }
-}
+        return {
+            id,
+            type: 'tonconnect',
+            metadata: {
+                name: 'TonConnect',
+                iconUrl: 'https://avatars.githubusercontent.com/u/113980577',
+                ...config.metadata,
+            },
+
+            get tonConnectUI() {
+                return getTonConnectUI();
+            },
+
+            getConnectedWallets,
+
+            async connectWallet(): Promise<void> {
+                const ui = getTonConnectUI();
+
+                if (ui) {
+                    await ui.openModal();
+                }
+            },
+
+            async disconnectWallet(): Promise<void> {
+                const ui = getTonConnectUI();
+
+                if (ui) {
+                    await ui.disconnect();
+                }
+            },
+
+            destroy() {
+                unsubscribeTonConnect?.();
+                originalTonConnectUI = null;
+            },
+        };
+    });
+};

package/src/connectors/tonconnect/index.ts

@@ -26,6 +26,9 @@ export { TonConnectWalletAdapter } from './adapters/ton-connect-wallet-adapter';
 export type { TonConnectWalletAdapterConfig } from './adapters/ton-connect-wallet-adapter';
 
 // Connector exports
-export { TonConnectConnector } from './connectors/ton-connect-connector';
+export {
+    createTonConnectConnector,
+    type TonConnectConnectorConfig,
+    type TonConnectConnector,
+} from './connectors/ton-connect-connector';
 export { TONCONNECT_DEFAULT_CONNECTOR_ID } from './constants/id';
-export type { TonConnectConnectorConfig } from './connectors/ton-connect-connector';

package/src/core/app-kit/services/app-kit.ts

@@ -6,18 +6,19 @@
  *
  */
 
-import { SwapManager } from '@ton/walletkit';
-import type { Provider } from 'src/types/provider';
+import { SwapManager, StreamingManager } from '@ton/walletkit';
+import type { ProviderInput, SwapProviderInterface, StakingProviderInterface } from '@ton/walletkit';
 
-import type { AppKitConfig } from '../types/config';
-import type { Connector } from '../../../types/connector';
-import { Emitter } from '../../emitter';
+import { StakingManager } from '../../../staking';
+import type { Connector, ConnectorFactoryContext, ConnectorInput } from '../../../types/connector';
+import { EventEmitter } from '../../emitter';
 import { CONNECTOR_EVENTS, WALLETS_EVENTS } from '../constants/events';
 import type { AppKitEmitter, AppKitEvents } from '../types/events';
 import type { WalletInterface } from '../../../types/wallet';
 import { WalletsManager } from '../../wallets-manager';
 import { AppKitNetworkManager } from '../../network';
 import { Network } from '../../../types/network';
+import type { AppKitConfig } from '../types/config';
 
 /**
  * Central hub for wallet management.
@@ -28,14 +29,16 @@ export class AppKit {
     readonly connectors: Connector[] = [];
     readonly walletsManager: WalletsManager;
     readonly swapManager: SwapManager;
+    readonly stakingManager: StakingManager;
 
     readonly networkManager: AppKitNetworkManager;
+    readonly streamingManager: StreamingManager;
     readonly config: AppKitConfig;
 
     constructor(config: AppKitConfig) {
         this.config = config;
 
-        this.emitter = new Emitter<AppKitEvents>();
+        this.emitter = new EventEmitter<AppKitEvents>();
         this.emitter.on(CONNECTOR_EVENTS.CONNECTED, this.updateWalletsFromConnectors.bind(this));
         this.emitter.on(CONNECTOR_EVENTS.DISCONNECTED, this.updateWalletsFromConnectors.bind(this));
 
@@ -46,25 +49,33 @@ export class AppKit {
 
         this.networkManager = new AppKitNetworkManager({ networks }, this.emitter);
         this.walletsManager = new WalletsManager(this.emitter);
-        this.swapManager = new SwapManager();
+
+        this.swapManager = new SwapManager(() => this.createFactoryContext());
+        this.stakingManager = new StakingManager(() => this.createFactoryContext());
+        this.streamingManager = new StreamingManager(() => this.createFactoryContext());
 
         if (config.connectors) {
-            config.connectors.forEach((connector) => {
-                this.addConnector(connector);
+            config.connectors.forEach((input) => {
+                this.addConnector(input);
             });
         }
 
         if (config.providers) {
-            config.providers.forEach((provider) => {
-                this.registerProvider(provider);
+            config.providers.forEach((input) => {
+                this.registerProvider(input);
             });
         }
     }
 
+    createFactoryContext(): ConnectorFactoryContext {
+        return { eventEmitter: this.emitter, networkManager: this.networkManager, ssr: this.config?.ssr };
+    }
+
     /**
      * Add a wallet connector
      */
-    addConnector(connector: Connector): () => void {
+    addConnector(input: ConnectorInput): () => void {
+        const connector = typeof input === 'function' ? input(this.createFactoryContext()) : input;
         const id = connector.id;
         const oldConnector = this.connectors.find((c) => c.id === id);
 
@@ -73,7 +84,6 @@ export class AppKit {
         }
 
         this.connectors.push(connector);
-        connector.initialize(this.emitter, this.networkManager);
 
         return () => {
             this.removeConnector(connector);
@@ -96,10 +106,14 @@ export class AppKit {
     /**
      * Add a provider
      */
-    registerProvider(provider: Provider): void {
+    registerProvider(input: ProviderInput): void {
+        const provider = typeof input === 'function' ? input(this.createFactoryContext()) : input;
         switch (provider.type) {
             case 'swap':
-                this.swapManager.registerProvider(provider);
+                this.swapManager.registerProvider(provider as SwapProviderInterface);
+                break;
+            case 'staking':
+                this.stakingManager.registerProvider(provider as StakingProviderInterface);
                 break;
             default:
                 throw new Error('Unknown provider type');

package/src/core/app-kit/types/config.ts

@@ -6,10 +6,9 @@
  *
  */
 
-import type { NetworkAdapters } from '@ton/walletkit';
+import type { NetworkAdapters, ProviderInput } from '@ton/walletkit';
 
-import type { Connector } from '../../../types/connector';
-import type { Provider } from '../../../types/provider';
+import type { ConnectorInput } from '../../../types/connector';
 import type { Network } from '../../../types/network';
 
 /**
@@ -25,6 +24,11 @@ export interface AppKitConfig {
      */
     networks?: NetworkAdapters;
 
+    /**
+     * Wallet connectors
+     */
+    connectors?: ConnectorInput[];
+
     /**
      * Default network for wallet connections.
      * If set, connectors (e.g. TonConnect) will enforce this network when connecting.
@@ -32,6 +36,10 @@ export interface AppKitConfig {
      */
     defaultNetwork?: Network;
 
-    connectors?: Connector[];
-    providers?: Provider[];
+    providers?: ProviderInput[];
+
+    /**
+     * Enable server-side rendering support
+     */
+    ssr?: boolean;
 }

package/src/core/app-kit/types/events.ts

@@ -6,9 +6,10 @@
  *
  */
 
-import type { Network } from '../../../types/network';
-import type { Emitter } from '../../emitter';
+import type { SharedKitEvents } from '../../emitter';
 import type { CONNECTOR_EVENTS, WALLETS_EVENTS, PLUGIN_EVENTS, NETWORKS_EVENTS } from '../constants/events';
+import type { Network } from '../../../types/network';
+import type { EventEmitter } from '../../emitter';
 import type { WalletInterface } from '../../../types/wallet';
 
 export interface WalletConnectedPayload {
@@ -29,7 +30,7 @@ export interface DefaultNetworkChangedPayload {
     network: Network | undefined;
 }
 
-export interface AppKitEvents {
+export type AppKitEvents = {
     // Connector events
     [CONNECTOR_EVENTS.CONNECTED]: WalletConnectedPayload;
     [CONNECTOR_EVENTS.DISCONNECTED]: WalletDisconnectedPayload;
@@ -44,6 +45,6 @@ export interface AppKitEvents {
 
     // Plugin events
     [PLUGIN_EVENTS.REGISTERED]: PluginRegisteredPayload;
-}
+} & SharedKitEvents;
 
-export type AppKitEmitter = Emitter<AppKitEvents>;
+export type AppKitEmitter = EventEmitter<AppKitEvents>;

package/src/core/emitter/index.ts

@@ -10,6 +10,6 @@
  * Events Feature
  * Provides Emitter implementation
  */
-export { Emitter } from './services/emitter';
+export { EventEmitter } from '@ton/walletkit';
 
-export type { EventPayload, AppKitEvent, EventListener } from './types/events';
+export type { EventPayload, KitEvent, EventListener, SharedKitEvents } from '@ton/walletkit';

package/src/core/streaming/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export {
+    StreamingManager,
+    TonCenterStreamingProvider,
+    createTonCenterStreamingProvider,
+    TonApiStreamingProvider,
+    createTonApiStreamingProvider,
+} from '@ton/walletkit';
+
+export type {
+    StreamingProvider,
+    StreamingProviderFactory,
+    StreamingAPI,
+    TonCenterStreamingProviderConfig,
+    TonApiStreamingProviderConfig,
+    BalanceUpdate,
+    TransactionsUpdate,
+    Transaction,
+    JettonUpdate,
+    StreamingUpdate,
+    StreamingWatchType,
+    StreamingEvents,
+} from '@ton/walletkit';

package/src/index.ts

@@ -29,9 +29,11 @@
 export * from './core/app-kit';
 export * from './core/emitter';
 export * from './core/network';
+export * from './core/streaming';
 export * from './connectors/tonconnect';
 
 export * from './swap';
+export * from './staking';
 
 // Actions
 export * from './actions';

package/src/queries/balances/get-balance-by-address.ts

@@ -6,13 +6,17 @@
  *
  */
 
+import type { QueryClient } from '@tanstack/query-core';
+
 import type { AppKit } from '../../core/app-kit';
 import { getBalanceByAddress } from '../../actions/balances/get-balance-by-address';
 import type { GetBalanceByAddressOptions } from '../../actions/balances/get-balance-by-address';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork, sleep } from '../../utils';
 import type { GetBalanceByAddressReturnType } from '../../actions/balances/get-balance-by-address';
+import type { BalanceUpdate } from '../../core/streaming';
+import type { Network } from '../../types/network';
 
 export type GetBalanceErrorType = Error;
 
@@ -25,8 +29,11 @@ export type GetBalanceByAddressQueryConfig<selectData = GetBalanceByAddressData>
 
 export const getBalanceByAddressQueryOptions = <selectData = GetBalanceByAddressData>(
     appKit: AppKit,
-    options: GetBalanceByAddressQueryConfig<selectData> = {},
+    initialOptions: GetBalanceByAddressQueryConfig<selectData> = {},
 ): GetBalanceByAddressQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.address && (options.query?.enabled ?? true)),
@@ -56,3 +63,23 @@ export type GetBalanceByAddressQueryOptions<selectData = GetBalanceByAddressData
     selectData,
     GetBalanceByAddressQueryKey
 >;
+
+/**
+ * Update the TanStack Query cache for an address balance.
+ */
+export const handleBalanceUpdate = (
+    queryClient: QueryClient,
+    { address, network }: { address: string; network: Network },
+    update: BalanceUpdate,
+) => {
+    if (update.status === 'finalized') {
+        const queryKey = getBalanceByAddressQueryKey({ address, network });
+        queryClient.setQueryData(queryKey, update.balance);
+        sleep(5000).then(() => queryClient.invalidateQueries({ queryKey }));
+    }
+
+    if (update.status === 'invalidated') {
+        const queryKey = getBalanceByAddressQueryKey({ address, network });
+        queryClient.invalidateQueries({ queryKey });
+    }
+};

package/src/queries/index.ts

@@ -9,6 +9,7 @@
 // Balances
 export {
     getBalanceByAddressQueryOptions,
+    handleBalanceUpdate,
     type GetBalanceByAddressData,
     type GetBalanceErrorType,
     type GetBalanceByAddressQueryConfig,
@@ -51,12 +52,14 @@ export {
 } from './jettons/get-jetton-wallet-address';
 export {
     getJettonBalanceByAddressQueryOptions,
+    handleJettonBalanceUpdate,
     type GetJettonBalanceByAddressQueryConfig,
     type GetJettonBalanceByAddressData,
     type GetJettonBalanceErrorType,
 } from './jettons/get-jetton-balance-by-address';
 export {
     getJettonsByAddressQueryOptions,
+    handleJettonsUpdate,
     type GetJettonsByAddressData,
     type GetJettonsErrorType,
     type GetJettonsByAddressQueryConfig,
@@ -162,6 +165,42 @@ export {
     type BuildSwapTransactionVariables,
 } from './swap/build-swap-transaction';
 
+// Staking
+export {
+    getStakingProvidersQueryOptions,
+    type GetStakingProvidersData,
+    type GetStakingProvidersErrorType,
+    type GetStakingProvidersQueryConfig,
+} from './staking/get-staking-providers';
+export {
+    getStakingQuoteQueryOptions,
+    type GetStakingQuoteQueryConfig,
+    type GetStakingQuoteQueryOptions,
+    type GetStakingQuoteData,
+    type GetStakingQuoteErrorType,
+    type GetStakingQuoteQueryFnData,
+    type GetStakingQuoteQueryKey,
+} from './staking/get-staking-quote';
+export {
+    getStakedBalanceQueryOptions,
+    type GetStakedBalanceQueryConfig,
+    type GetStakedBalanceData,
+    type GetStakedBalanceErrorType,
+} from './staking/get-staked-balance';
+export {
+    getStakingProviderInfoQueryOptions,
+    type GetStakingProviderInfoQueryConfig,
+    type GetStakingProviderInfoData,
+    type GetStakingProviderInfoErrorType,
+} from './staking/get-staking-provider-info';
+export {
+    buildStakeTransactionMutationOptions,
+    type BuildStakeTransactionData,
+    type BuildStakeTransactionErrorType,
+    type BuildStakeTransactionMutationOptions,
+    type BuildStakeTransactionVariables,
+} from './staking/build-stake-transaction';
+
 // Transaction
 export {
     transferTonMutationOptions,

package/src/queries/jettons/get-jetton-balance-by-address.ts

@@ -6,6 +6,7 @@
  *
  */
 
+import type { QueryClient } from '@tanstack/query-core';
 import type { TokenAmount } from '@ton/walletkit';
 
 import type { AppKit } from '../../core/app-kit';
@@ -13,7 +14,9 @@ import { getJettonBalance } from '../../actions/jettons/get-jetton-balance';
 import type { GetJettonBalanceOptions as GetJettonBalanceParameters } from '../../actions/jettons/get-jetton-balance';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork, sleep } from '../../utils';
+import type { JettonUpdate } from '../../core/streaming';
+import type { Network } from '../../types/network';
 
 export type GetJettonBalanceErrorType = Error;
 
@@ -31,8 +34,11 @@ export type GetJettonBalanceByAddressQueryConfig<selectData = GetJettonBalanceBy
 
 export const getJettonBalanceByAddressQueryOptions = <selectData = GetJettonBalanceByAddressData>(
     appKit: AppKit,
-    options: GetJettonBalanceByAddressQueryConfig<selectData> = {},
+    initialOptions: GetJettonBalanceByAddressQueryConfig<selectData> = {},
 ): GetJettonBalanceByAddressQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.jettonAddress && options.ownerAddress && (options.query?.enabled ?? true)),
@@ -67,3 +73,31 @@ export type GetJettonBalanceByAddressQueryOptions<selectData = GetJettonBalanceB
     selectData,
     GetJettonBalanceByAddressQueryKey
 >;
+
+/**
+ * Update the TanStack Query cache for an owner jetton balance.
+ */
+export const handleJettonBalanceUpdate = (
+    queryClient: QueryClient,
+    { ownerAddress, jettonAddress, network }: { ownerAddress: string; jettonAddress: string; network: Network },
+    update: JettonUpdate,
+) => {
+    if (update.status === 'finalized') {
+        const queryKey = getJettonBalanceByAddressQueryKey({
+            ownerAddress,
+            jettonAddress,
+            network,
+        });
+        queryClient.setQueryData(queryKey, update.balance);
+        sleep(5000).then(() => queryClient.invalidateQueries({ queryKey }));
+    }
+
+    if (update.status === 'invalidated') {
+        const queryKey = getJettonBalanceByAddressQueryKey({
+            ownerAddress,
+            jettonAddress,
+            network,
+        });
+        queryClient.invalidateQueries({ queryKey });
+    }
+};

package/src/queries/jettons/get-jetton-info.ts

@@ -12,7 +12,7 @@ import type { GetJettonInfoOptions } from '../../actions/jettons/get-jetton-info
 import type { GetJettonInfoReturnType } from '../../actions/jettons/get-jetton-info';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork } from '../../utils';
 
 export type GetJettonInfoErrorType = Error;
 
@@ -21,8 +21,11 @@ export type GetJettonInfoQueryConfig<selectData = GetJettonInfoData> = Compute<E
 
 export const getJettonInfoQueryOptions = <selectData = GetJettonInfoData>(
     appKit: AppKit,
-    options: GetJettonInfoQueryConfig<selectData> = {},
+    initialOptions: GetJettonInfoQueryConfig<selectData> = {},
 ): GetJettonInfoQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.address && (options.query?.enabled ?? true)),