@ton/appkit 0.0.5-alpha.1 → 0.0.5-alpha.3

package/src/queries/jettons/get-jetton-wallet-address.ts

@@ -13,7 +13,7 @@ import { getJettonWalletAddress } from '../../actions/jettons/get-jetton-wallet-
 import type { GetJettonWalletAddressOptions as GetJettonWalletAddressParameters } from '../../actions/jettons/get-jetton-wallet-address';
 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 GetJettonWalletAddressErrorType = Error;
 
@@ -29,8 +29,11 @@ export type GetJettonWalletAddressQueryConfig<selectData = GetJettonWalletAddres
 
 export const getJettonWalletAddressQueryOptions = <selectData = GetJettonWalletAddressData>(
     appKit: AppKit,
-    options: GetJettonWalletAddressQueryConfig<selectData> = {},
+    initialOptions: GetJettonWalletAddressQueryConfig<selectData> = {},
 ): GetJettonWalletAddressQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.jettonAddress && options.ownerAddress && (options.query?.enabled ?? true)),

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

@@ -6,13 +6,17 @@
  *
  */
 
+import type { QueryClient } from '@tanstack/query-core';
+
 import type { AppKit } from '../../core/app-kit';
 import { getJettonsByAddress } from '../../actions/jettons/get-jettons-by-address';
 import type { GetJettonsByAddressOptions } from '../../actions/jettons/get-jettons-by-address';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork, compareAddress, formatUnits, sleep } from '../../utils';
 import type { GetJettonsByAddressReturnType } from '../../actions/jettons/get-jettons-by-address';
+import type { JettonUpdate } from '../../core/streaming';
+import type { Network } from '../../types/network';
 
 export type GetJettonsErrorType = Error;
 
@@ -25,8 +29,11 @@ export type GetJettonsByAddressQueryConfig<selectData = GetJettonsByAddressData>
 
 export const getJettonsByAddressQueryOptions = <selectData = GetJettonsByAddressData>(
     appKit: AppKit,
-    options: GetJettonsByAddressQueryConfig<selectData> = {},
+    initialOptions: GetJettonsByAddressQueryConfig<selectData> = {},
 ): GetJettonsByAddressQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.address && (options.query?.enabled ?? true)),
@@ -57,3 +64,42 @@ export type GetJettonsByAddressQueryOptions<selectData = GetJettonsByAddressData
     selectData,
     GetJettonsByAddressQueryKey
 >;
+
+/**
+ * Update the TanStack Query cache for an address jettons list.
+ */
+export const handleJettonsUpdate = (
+    queryClient: QueryClient,
+    { address, network }: { address: string; network: Network },
+    update: JettonUpdate,
+) => {
+    if (update.status === 'finalized') {
+        const queryKey = getJettonsByAddressQueryKey({ address, network });
+        const currentData = queryClient.getQueryData(queryKey) as GetJettonsByAddressData | undefined;
+
+        if (currentData?.jettons) {
+            const jetton = currentData.jettons.find((j) => compareAddress(j.address, update.masterAddress));
+            const decimals = jetton?.decimalsNumber ?? update.decimals;
+
+            if (jetton && decimals) {
+                const updatedJetton = {
+                    ...jetton,
+                    balance: formatUnits(update.rawBalance, decimals),
+                };
+                const newJettons = currentData.jettons.map((j) =>
+                    compareAddress(j.address, update.masterAddress) ? updatedJetton : j,
+                );
+                queryClient.setQueryData(queryKey, {
+                    ...currentData,
+                    jettons: newJettons,
+                });
+            }
+        }
+        sleep(5000).then(() => queryClient.invalidateQueries({ queryKey }));
+    }
+
+    if (update.status === 'invalidated') {
+        const queryKey = getJettonsByAddressQueryKey({ address, network });
+        queryClient.invalidateQueries({ queryKey });
+    }
+};

package/src/queries/network/get-block-number.ts

@@ -11,7 +11,7 @@ import { getBlockNumber } from '../../actions/network/get-block-number';
 import type { GetBlockNumberOptions } from '../../actions/network/get-block-number';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork } from '../../utils';
 import type { GetBlockNumberReturnType } from '../../actions/network/get-block-number';
 
 export type GetBlockNumberErrorType = Error;
@@ -23,8 +23,11 @@ export type GetBlockNumberQueryConfig<selectData = GetBlockNumberData> = Compute
 
 export const getBlockNumberQueryOptions = <selectData = GetBlockNumberData>(
     appKit: AppKit,
-    options: GetBlockNumberQueryConfig<selectData> = {},
+    initialOptions: GetBlockNumberQueryConfig<selectData> = {},
 ): GetBlockNumberQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         gcTime: 0,

package/src/queries/nft/get-nft.ts

@@ -13,7 +13,7 @@ import { getNft } from '../../actions/nft/get-nft';
 import type { GetNftOptions as GetNftParameters } from '../../actions/nft/get-nft';
 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 GetNftErrorType = Error;
 
@@ -22,8 +22,11 @@ export type GetNftQueryConfig<selectData = GetNftData> = Compute<ExactPartial<Ge
 
 export const getNftQueryOptions = <selectData = GetNftData>(
     appKit: AppKit,
-    options: GetNftQueryConfig<selectData> = {},
+    initialOptions: GetNftQueryConfig<selectData> = {},
 ): GetNftQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.address && (options.query?.enabled ?? true)),

package/src/queries/nft/get-nfts-by-address.ts

@@ -11,7 +11,7 @@ import { getNftsByAddress } from '../../actions/nft/get-nfts-by-address';
 import type { GetNftsByAddressOptions } from '../../actions/nft/get-nfts-by-address';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute, ExactPartial } from '../../types/utils';
-import { filterQueryOptions } from '../../utils';
+import { filterQueryOptions, resolveNetwork } from '../../utils';
 import type { GetNftsByAddressReturnType } from '../../actions/nft/get-nfts-by-address';
 
 export type GetNFTsErrorType = Error;
@@ -25,8 +25,11 @@ export type GetNFTsByAddressQueryConfig<selectData = GetNFTsByAddressData> = Com
 
 export const getNFTsByAddressQueryOptions = <selectData = GetNFTsByAddressData>(
     appKit: AppKit,
-    options: GetNFTsByAddressQueryConfig<selectData> = {},
+    initialOptions: GetNFTsByAddressQueryConfig<selectData> = {},
 ): GetNFTsByAddressQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.address && (options.query?.enabled ?? true)),

package/src/queries/staking/build-stake-transaction.ts

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ *
+ */
+
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core';
+
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+import { buildStakeTransaction } from '../../actions/staking/build-stake-transaction';
+import type {
+    BuildStakeTransactionOptions,
+    BuildStakeTransactionReturnType,
+} from '../../actions/staking/build-stake-transaction';
+
+export type BuildStakeTransactionMutationOptions<context = unknown> = MutationParameter<
+    BuildStakeTransactionData,
+    BuildStakeTransactionErrorType,
+    BuildStakeTransactionVariables,
+    context
+>;
+
+export const buildStakeTransactionMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: BuildStakeTransactionMutationOptions<context> = {},
+): BuildStakeTransactionMutationConfig<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return buildStakeTransaction(appKit, variables);
+        },
+        mutationKey: ['buildStakeTransaction'],
+    };
+};
+
+export type BuildStakeTransactionMutationConfig<context = unknown> = MutationOptions<
+    BuildStakeTransactionData,
+    BuildStakeTransactionErrorType,
+    BuildStakeTransactionVariables,
+    context
+>;
+
+export type BuildStakeTransactionData = Compute<Awaited<BuildStakeTransactionReturnType>>;
+
+export type BuildStakeTransactionErrorType = Error;
+
+export type BuildStakeTransactionVariables = BuildStakeTransactionOptions;
+
+export type BuildStakeTransactionMutate<context = unknown> = (
+    variables: BuildStakeTransactionVariables,
+    options?:
+        | Compute<
+              MutateOptions<
+                  BuildStakeTransactionData,
+                  BuildStakeTransactionErrorType,
+                  Compute<BuildStakeTransactionVariables>,
+                  context
+              >
+          >
+        | undefined,
+) => void;
+
+export type BuildStakeTransactionMutateAsync<context = unknown> = (
+    variables: BuildStakeTransactionVariables,
+    options?:
+        | Compute<
+              MutateOptions<
+                  BuildStakeTransactionData,
+                  BuildStakeTransactionErrorType,
+                  Compute<BuildStakeTransactionVariables>,
+                  context
+              >
+          >
+        | undefined,
+) => Promise<BuildStakeTransactionData>;

package/src/queries/staking/get-staked-balance.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ *
+ */
+
+import { getStakedBalance } from '../../actions/staking/get-staked-balance';
+import type { GetStakedBalanceOptions } from '../../actions/staking/get-staked-balance';
+import type { GetStakedBalanceReturnType } from '../../actions/staking/get-staked-balance';
+import type { AppKit } from '../../core/app-kit';
+import type { QueryOptions, QueryParameter } from '../../types/query';
+import type { Compute, ExactPartial } from '../../types/utils';
+import { filterQueryOptions } from '../../utils';
+
+export type GetStakedBalanceErrorType = Error;
+
+export type GetStakedBalanceQueryConfig<selectData = GetStakedBalanceData> = Compute<
+    ExactPartial<GetStakedBalanceOptions>
+> &
+    QueryParameter<GetStakedBalanceQueryFnData, GetStakedBalanceErrorType, selectData, GetStakedBalanceQueryKey>;
+
+export const getStakedBalanceQueryOptions = <selectData = GetStakedBalanceData>(
+    appKit: AppKit,
+    options: GetStakedBalanceQueryConfig<selectData> = {},
+): GetStakedBalanceQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.userAddress && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetStakedBalanceOptions];
+            if (!parameters.userAddress) {
+                throw new Error('userAddress is required');
+            }
+
+            return getStakedBalance(appKit, parameters);
+        },
+        queryKey: getStakedBalanceQueryKey(options),
+    };
+};
+
+export type GetStakedBalanceQueryFnData = Compute<Awaited<GetStakedBalanceReturnType>>;
+
+export type GetStakedBalanceData = GetStakedBalanceQueryFnData;
+
+export const getStakedBalanceQueryKey = (
+    options: Compute<ExactPartial<GetStakedBalanceOptions>> = {},
+): GetStakedBalanceQueryKey => {
+    return ['stakedBalance', filterQueryOptions(options as unknown as Record<string, unknown>)] as const;
+};
+
+export type GetStakedBalanceQueryKey = readonly ['stakedBalance', Compute<ExactPartial<GetStakedBalanceOptions>>];
+
+export type GetStakedBalanceQueryOptions<selectData = GetStakedBalanceData> = QueryOptions<
+    GetStakedBalanceQueryFnData,
+    GetStakedBalanceErrorType,
+    selectData,
+    GetStakedBalanceQueryKey
+>;

package/src/queries/staking/get-staking-provider-info.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ *
+ */
+
+import { getStakingProviderInfo } from '../../actions/staking/get-staking-provider-info';
+import type { GetStakingProviderInfoOptions } from '../../actions/staking/get-staking-provider-info';
+import type { GetStakingProviderInfoReturnType } from '../../actions/staking/get-staking-provider-info';
+import type { AppKit } from '../../core/app-kit';
+import type { QueryOptions, QueryParameter } from '../../types/query';
+import type { Compute, ExactPartial } from '../../types/utils';
+import { filterQueryOptions } from '../../utils';
+
+export type GetStakingProviderInfoErrorType = Error;
+
+export type GetStakingProviderInfoQueryConfig<selectData = GetStakingProviderInfoData> = Compute<
+    ExactPartial<GetStakingProviderInfoOptions>
+> &
+    QueryParameter<
+        GetStakingProviderInfoQueryFnData,
+        GetStakingProviderInfoErrorType,
+        selectData,
+        GetStakingProviderInfoQueryKey
+    >;
+
+export const getStakingProviderInfoQueryOptions = <selectData = GetStakingProviderInfoData>(
+    appKit: AppKit,
+    options: GetStakingProviderInfoQueryConfig<selectData> = {},
+): GetStakingProviderInfoQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetStakingProviderInfoOptions];
+            return getStakingProviderInfo(appKit, parameters);
+        },
+        queryKey: getStakingProviderInfoQueryKey(options),
+    };
+};
+
+export type GetStakingProviderInfoQueryFnData = Compute<Awaited<GetStakingProviderInfoReturnType>>;
+
+export type GetStakingProviderInfoData = GetStakingProviderInfoQueryFnData;
+
+export const getStakingProviderInfoQueryKey = (
+    options: Compute<ExactPartial<GetStakingProviderInfoOptions>> = {},
+): GetStakingProviderInfoQueryKey => {
+    return ['stakingProviderInfo', filterQueryOptions(options as unknown as Record<string, unknown>)] as const;
+};
+
+export type GetStakingProviderInfoQueryKey = readonly [
+    'stakingProviderInfo',
+    Compute<ExactPartial<GetStakingProviderInfoOptions>>,
+];
+
+export type GetStakingProviderInfoQueryOptions<selectData = GetStakingProviderInfoData> = QueryOptions<
+    GetStakingProviderInfoQueryFnData,
+    GetStakingProviderInfoErrorType,
+    selectData,
+    GetStakingProviderInfoQueryKey
+>;

package/src/queries/staking/get-staking-providers.ts

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ *
+ */
+
+import { getStakingProviders } from '../../actions/staking/get-staking-providers';
+import type { GetStakingProvidersReturnType } from '../../actions/staking/get-staking-providers';
+import type { AppKit } from '../../core/app-kit';
+import type { QueryOptions, QueryParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type GetStakingProvidersErrorType = Error;
+
+export type GetStakingProvidersQueryConfig<selectData = GetStakingProvidersData> = QueryParameter<
+    GetStakingProvidersQueryFnData,
+    GetStakingProvidersErrorType,
+    selectData,
+    GetStakingProvidersQueryKey
+>;
+
+export const getStakingProvidersQueryOptions = <selectData = GetStakingProvidersData>(
+    appKit: AppKit,
+    options: GetStakingProvidersQueryConfig<selectData> = {},
+): GetStakingProvidersQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        queryFn: async () => {
+            return getStakingProviders(appKit);
+        },
+        queryKey: getStakingProvidersQueryKey(),
+    };
+};
+
+export type GetStakingProvidersQueryFnData = Compute<Awaited<GetStakingProvidersReturnType>>;
+
+export type GetStakingProvidersData = GetStakingProvidersQueryFnData;
+
+export const getStakingProvidersQueryKey = (): GetStakingProvidersQueryKey => {
+    return ['stakingProviders'] as const;
+};
+
+export type GetStakingProvidersQueryKey = readonly ['stakingProviders'];
+
+export type GetStakingProvidersQueryOptions<selectData = GetStakingProvidersData> = QueryOptions<
+    GetStakingProvidersQueryFnData,
+    GetStakingProvidersErrorType,
+    selectData,
+    GetStakingProvidersQueryKey
+>;

package/src/queries/staking/get-staking-quote.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ *
+ */
+
+import { getStakingQuote } from '../../actions/staking/get-staking-quote';
+import type { GetStakingQuoteOptions } from '../../actions/staking/get-staking-quote';
+import type { GetStakingQuoteReturnType } from '../../actions/staking/get-staking-quote';
+import type { AppKit } from '../../core/app-kit';
+import type { QueryOptions, QueryParameter } from '../../types/query';
+import type { Compute, ExactPartial } from '../../types/utils';
+import { filterQueryOptions } from '../../utils';
+
+export type GetStakingQuoteErrorType = Error;
+
+export type GetStakingQuoteQueryConfig<selectData = GetStakingQuoteData> = Compute<
+    ExactPartial<GetStakingQuoteOptions>
+> &
+    QueryParameter<GetStakingQuoteQueryFnData, GetStakingQuoteErrorType, selectData, GetStakingQuoteQueryKey>;
+
+export const getStakingQuoteQueryOptions = <selectData = GetStakingQuoteData>(
+    appKit: AppKit,
+    options: GetStakingQuoteQueryConfig<selectData> = {},
+): GetStakingQuoteQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.amount && options.direction && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetStakingQuoteOptions];
+            if (!parameters.amount || !parameters.direction) {
+                throw new Error('amount and direction are required');
+            }
+
+            return getStakingQuote(appKit, parameters);
+        },
+        queryKey: getStakingQuoteQueryKey(options),
+    };
+};
+
+export type GetStakingQuoteQueryFnData = Compute<Awaited<GetStakingQuoteReturnType>>;
+
+export type GetStakingQuoteData = GetStakingQuoteQueryFnData;
+
+export const getStakingQuoteQueryKey = (
+    options: Compute<ExactPartial<GetStakingQuoteOptions>> = {},
+): GetStakingQuoteQueryKey => {
+    return ['stakingQuote', filterQueryOptions(options as unknown as Record<string, unknown>)] as const;
+};
+
+export type GetStakingQuoteQueryKey = readonly ['stakingQuote', Compute<ExactPartial<GetStakingQuoteOptions>>];
+
+export type GetStakingQuoteQueryOptions<selectData = GetStakingQuoteData> = QueryOptions<
+    GetStakingQuoteQueryFnData,
+    GetStakingQuoteErrorType,
+    selectData,
+    GetStakingQuoteQueryKey
+>;

package/src/queries/streaming-updates.test.ts

@@ -0,0 +1,104 @@
+/**
+ * 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.
+ *
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { QueryClient } from '@tanstack/query-core';
+
+import { handleBalanceUpdate } from './balances/get-balance-by-address';
+import { handleJettonBalanceUpdate } from './jettons/get-jetton-balance-by-address';
+import { handleJettonsUpdate } from './jettons/get-jettons-by-address';
+import { Network } from '../types/network';
+import type { BalanceUpdate, JettonUpdate } from '../core/streaming';
+
+describe('Streaming Updates Handlers', () => {
+    let queryClient: QueryClient;
+
+    beforeEach(() => {
+        queryClient = {
+            setQueryData: vi.fn(),
+            invalidateQueries: vi.fn(),
+            getQueryData: vi.fn(),
+        } as unknown as QueryClient;
+    });
+
+    const network = Network.mainnet();
+
+    describe('handleBalanceUpdate', () => {
+        it('should invalidate query immediately on invalidated status', () => {
+            const address = 'EQD...';
+            const update: BalanceUpdate = {
+                type: 'balance',
+                address,
+                balance: '100',
+                rawBalance: '100000000',
+                status: 'invalidated',
+            };
+
+            handleBalanceUpdate(queryClient, { address, network }, update);
+
+            expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
+                queryKey: expect.arrayContaining(['balance']),
+            });
+            expect(queryClient.setQueryData).not.toHaveBeenCalled();
+        });
+
+        it('should update data on finalized status', () => {
+            const address = 'EQD...';
+            const update: BalanceUpdate = {
+                type: 'balance',
+                address,
+                balance: '100',
+                rawBalance: '100000000',
+                status: 'finalized',
+            };
+
+            handleBalanceUpdate(queryClient, { address, network }, update);
+
+            expect(queryClient.setQueryData).toHaveBeenCalled();
+        });
+    });
+
+    describe('handleJettonBalanceUpdate', () => {
+        it('should invalidate query immediately on invalidated status', () => {
+            const ownerAddress = 'EQO...';
+            const jettonAddress = 'EQJ...';
+            const update: JettonUpdate = {
+                type: 'jettons',
+                ownerAddress,
+                masterAddress: jettonAddress,
+                walletAddress: jettonAddress,
+                rawBalance: '50',
+                status: 'invalidated',
+            };
+
+            handleJettonBalanceUpdate(queryClient, { ownerAddress, jettonAddress, network }, update);
+
+            expect(queryClient.invalidateQueries).toHaveBeenCalled();
+            expect(queryClient.setQueryData).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('handleJettonsUpdate', () => {
+        it('should invalidate query immediately on invalidated status', () => {
+            const address = 'EQA...';
+            const update: JettonUpdate = {
+                type: 'jettons',
+                ownerAddress: address,
+                masterAddress: address,
+                walletAddress: address,
+                rawBalance: '0',
+                status: 'invalidated',
+            };
+
+            handleJettonsUpdate(queryClient, { address, network }, update);
+
+            expect(queryClient.invalidateQueries).toHaveBeenCalled();
+            expect(queryClient.setQueryData).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/queries/swap/get-swap-quote.ts

@@ -12,7 +12,7 @@ import type { GetSwapQuoteReturnType } from '../../actions/swap/get-swap-quote';
 import type { AppKit } from '../../core/app-kit';
 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 GetSwapQuoteErrorType = Error;
 
@@ -21,8 +21,11 @@ export type GetSwapQuoteQueryConfig<selectData = GetSwapQuoteData> = Compute<Exa
 
 export const getSwapQuoteQueryOptions = <selectData = GetSwapQuoteData>(
     appKit: AppKit,
-    options: GetSwapQuoteQueryConfig<selectData> = {},
+    initialOptions: GetSwapQuoteQueryConfig<selectData> = {},
 ): GetSwapQuoteQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         enabled: Boolean(options.amount && options.from && options.to && (options.query?.enabled ?? true)),

package/src/queries/transaction/get-transaction-status.ts

@@ -15,6 +15,7 @@ import type {
 import type { AppKit } from '../../core/app-kit';
 import type { QueryOptions, QueryParameter } from '../../types/query';
 import type { Compute } from '../../types/utils';
+import { resolveNetwork } from '../../utils';
 
 export type { GetTransactionStatusErrorType, GetTransactionStatusParameters, GetTransactionStatusReturnType };
 
@@ -38,8 +39,11 @@ export type GetTransactionStatusQueryOptions<selectData = GetTransactionStatusDa
 
 export const getTransactionStatusQueryOptions = <selectData = GetTransactionStatusData>(
     appKit: AppKit,
-    options: GetTransactionStatusParameters & GetTransactionStatusQueryConfig<selectData>,
+    initialOptions: GetTransactionStatusParameters & GetTransactionStatusQueryConfig<selectData>,
 ): GetTransactionStatusQueryOptions<selectData> => {
+    const network = resolveNetwork(appKit, initialOptions.network);
+    const options = { ...initialOptions, network };
+
     return {
         ...options.query,
         queryFn: () => {

package/src/staking/index.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { StakingProvider, UnstakeMode, StakingError, StakingManager } from '@ton/walletkit';
+
+export type {
+    UnstakeModes,
+    StakeParams,
+    StakingAPI,
+    StakingQuote,
+    StakingQuoteParams,
+    StakingBalance,
+    StakingProviderInfo,
+    StakingProviderInterface,
+    StakingQuoteDirection,
+} from '@ton/walletkit';

package/src/staking/tonstakers/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 * from '@ton/walletkit/staking/tonstakers';