@ton/appkit 0.0.1-alpha.2 → 0.0.1

package/src/queries/connectors/disconnect.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { disconnect } from '../../actions/connectors/disconnect';
+import type { DisconnectParameters, DisconnectReturnType } from '../../actions/connectors/disconnect';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type { DisconnectParameters, DisconnectReturnType };
+
+export type DisconnectErrorType = Error;
+
+export type DisconnectOptions<context = unknown> = MutationParameter<
+    DisconnectData,
+    DisconnectErrorType,
+    DisconnectVariables,
+    context
+>;
+
+export const disconnectMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: DisconnectOptions<context> = {},
+): DisconnectMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return disconnect(appKit, variables);
+        },
+        mutationKey: ['disconnect'],
+    };
+};
+
+export type DisconnectMutationOptions<context = unknown> = MutationOptions<
+    DisconnectData,
+    DisconnectErrorType,
+    DisconnectVariables,
+    context
+>;
+
+export type DisconnectData = Compute<DisconnectReturnType>;
+
+export type DisconnectVariables = DisconnectParameters;
+
+export type DisconnectMutate<context = unknown> = (
+    variables: DisconnectVariables,
+    options?:
+        | Compute<MutateOptions<DisconnectData, DisconnectErrorType, Compute<DisconnectVariables>, context>>
+        | undefined,
+) => void;
+
+export type DisconnectMutateAsync<context = unknown> = (
+    variables: DisconnectVariables,
+    options?:
+        | Compute<MutateOptions<DisconnectData, DisconnectErrorType, Compute<DisconnectVariables>, context>>
+        | undefined,
+) => Promise<DisconnectData>;

package/src/queries/index.ts

@@ -0,0 +1,181 @@
+/**
+ * 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.
+ *
+ */
+
+// Balances
+export {
+    getBalanceByAddressQueryOptions,
+    type GetBalanceByAddressData,
+    type GetBalanceErrorType,
+    type GetBalanceByAddressQueryConfig,
+} from './balances/get-balance-by-address';
+
+// Connectors
+export {
+    connectMutationOptions,
+    type ConnectMutationOptions,
+    type ConnectParameters,
+    type ConnectReturnType,
+    type ConnectData,
+    type ConnectErrorType,
+    type ConnectOptions,
+    type ConnectVariables,
+} from './connectors/connect';
+export {
+    disconnectMutationOptions,
+    type DisconnectMutationOptions,
+    type DisconnectParameters,
+    type DisconnectReturnType,
+    type DisconnectData,
+    type DisconnectErrorType,
+    type DisconnectOptions,
+    type DisconnectVariables,
+} from './connectors/disconnect';
+
+// Jettons
+export {
+    getJettonInfoQueryOptions,
+    type GetJettonInfoQueryConfig,
+    type GetJettonInfoData,
+    type GetJettonInfoErrorType,
+} from './jettons/get-jetton-info';
+export {
+    getJettonWalletAddressQueryOptions,
+    type GetJettonWalletAddressQueryConfig,
+    type GetJettonWalletAddressData,
+    type GetJettonWalletAddressErrorType,
+} from './jettons/get-jetton-wallet-address';
+export {
+    getJettonBalanceByAddressQueryOptions,
+    type GetJettonBalanceByAddressQueryConfig,
+    type GetJettonBalanceByAddressData,
+    type GetJettonBalanceErrorType,
+} from './jettons/get-jetton-balance-by-address';
+export {
+    getJettonsByAddressQueryOptions,
+    type GetJettonsByAddressData,
+    type GetJettonsErrorType,
+    type GetJettonsByAddressQueryConfig,
+} from './jettons/get-jettons-by-address';
+export {
+    transferJettonMutationOptions,
+    type TransferJettonData,
+    type TransferJettonErrorType,
+    type TransferJettonMutate,
+    type TransferJettonMutateAsync,
+    type TransferJettonMutationOptions,
+    type TransferJettonOptions,
+    type TransferJettonVariables,
+    type TransferJettonParameters,
+    type TransferJettonReturnType,
+} from './jettons/transfer-jetton';
+
+// NFT
+export {
+    getNFTsByAddressQueryOptions as getNFTsQueryOptions,
+    type GetNFTsByAddressQueryConfig as GetNFTsQueryConfig,
+    type GetNFTsByAddressData as GetNFTsData,
+    type GetNFTsErrorType,
+} from './nft/get-nfts-by-address';
+export {
+    getNftQueryOptions,
+    type GetNftQueryConfig,
+    type GetNftData,
+    type GetNftErrorType,
+    type GetNftQueryOptions,
+} from './nft/get-nft';
+export {
+    transferNftMutationOptions,
+    type TransferNftData,
+    type TransferNftErrorType,
+    type TransferNftMutate,
+    type TransferNftMutateAsync,
+    type TransferNftMutationOptions,
+    type TransferNftOptions,
+    type TransferNftVariables,
+    type TransferNftParameters,
+    type TransferNftReturnType,
+} from './nft/transfer-nft';
+
+// Signing
+export {
+    signTextMutationOptions,
+    type SignTextOptions,
+    type SignTextMutationOptions,
+    type SignTextData,
+    type SignTextVariables,
+    type SignTextMutate,
+    type SignTextMutateAsync,
+    type SignTextErrorType,
+} from './signing/sign-text';
+export {
+    signBinaryMutationOptions,
+    type SignBinaryOptions,
+    type SignBinaryMutationOptions,
+    type SignBinaryData,
+    type SignBinaryVariables,
+    type SignBinaryMutate,
+    type SignBinaryMutateAsync,
+    type SignBinaryErrorType,
+} from './signing/sign-binary';
+export {
+    signCellMutationOptions,
+    type SignCellOptions,
+    type SignCellMutationOptions,
+    type SignCellData,
+    type SignCellVariables,
+    type SignCellMutate,
+    type SignCellMutateAsync,
+    type SignCellErrorType,
+} from './signing/sign-cell';
+
+// Swap
+export {
+    getSwapQuoteQueryOptions,
+    type GetSwapQuoteQueryConfig,
+    type GetSwapQuoteQueryOptions,
+    type GetSwapQuoteData,
+    type GetSwapQuoteErrorType,
+    type GetSwapQuoteQueryFnData,
+    type GetSwapQuoteQueryKey,
+} from './swap/get-swap-quote';
+export {
+    buildSwapTransactionMutationOptions,
+    type BuildSwapTransactionMutationConfig,
+    type BuildSwapTransactionMutationOptions,
+    type BuildSwapTransactionData,
+    type BuildSwapTransactionErrorType,
+    type BuildSwapTransactionMutate,
+    type BuildSwapTransactionMutateAsync,
+    type BuildSwapTransactionVariables,
+} from './swap/build-swap-transaction';
+
+// Transaction
+export {
+    transferTonMutationOptions,
+    type TransferTonData,
+    type TransferTonErrorType,
+    type TransferTonMutate,
+    type TransferTonMutateAsync,
+    type TransferTonMutationOptions,
+    type TransferTonOptions,
+    type TransferTonVariables,
+    type TransferTonParameters,
+    type TransferTonReturnType,
+} from './transaction/transfer-ton';
+export {
+    sendTransactionMutationOptions,
+    type SendTransactionData,
+    type SendTransactionErrorType,
+    type SendTransactionMutate,
+    type SendTransactionMutateAsync,
+    type SendTransactionMutationOptions,
+    type SendTransactionOptions,
+    type SendTransactionVariables,
+    type SendTransactionParameters,
+    type SendTransactionReturnType,
+} from './transaction/send-transaction';

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

@@ -0,0 +1,69 @@
+/**
+ * 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 { TokenAmount } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+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';
+
+export type GetJettonBalanceErrorType = Error;
+
+export type GetJettonBalanceByAddressData = GetJettonBalanceQueryFnData;
+
+export type GetJettonBalanceByAddressQueryConfig<selectData = GetJettonBalanceByAddressData> = Compute<
+    ExactPartial<GetJettonBalanceParameters>
+> &
+    QueryParameter<
+        GetJettonBalanceQueryFnData,
+        GetJettonBalanceErrorType,
+        selectData,
+        GetJettonBalanceByAddressQueryKey
+    >;
+
+export const getJettonBalanceByAddressQueryOptions = <selectData = GetJettonBalanceByAddressData>(
+    appKit: AppKit,
+    options: GetJettonBalanceByAddressQueryConfig<selectData> = {},
+): GetJettonBalanceByAddressQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.jettonAddress && options.ownerAddress && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetJettonBalanceParameters];
+            if (!parameters.jettonAddress) throw new Error('jettonAddress is required');
+            if (!parameters.ownerAddress) throw new Error('ownerAddress is required');
+
+            const balance = await getJettonBalance(appKit, parameters);
+            return balance;
+        },
+        queryKey: getJettonBalanceByAddressQueryKey(options),
+    };
+};
+
+export type GetJettonBalanceQueryFnData = Compute<TokenAmount>;
+
+export const getJettonBalanceByAddressQueryKey = (
+    options: Compute<ExactPartial<GetJettonBalanceParameters>> = {},
+): GetJettonBalanceByAddressQueryKey => {
+    return ['jetton-balance', filterQueryOptions(options)] as const;
+};
+
+export type GetJettonBalanceByAddressQueryKey = readonly [
+    'jetton-balance',
+    Compute<ExactPartial<GetJettonBalanceParameters>>,
+];
+
+export type GetJettonBalanceByAddressQueryOptions<selectData = GetJettonBalanceByAddressData> = QueryOptions<
+    GetJettonBalanceQueryFnData,
+    GetJettonBalanceErrorType,
+    selectData,
+    GetJettonBalanceByAddressQueryKey
+>;

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

@@ -0,0 +1,57 @@
+/**
+ * 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 { AppKit } from '../../core/app-kit';
+import { getJettonInfo } from '../../actions/jettons/get-jetton-info';
+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';
+
+export type GetJettonInfoErrorType = Error;
+
+export type GetJettonInfoQueryConfig<selectData = GetJettonInfoData> = Compute<ExactPartial<GetJettonInfoOptions>> &
+    QueryParameter<GetJettonInfoQueryFnData, GetJettonInfoErrorType, selectData, GetJettonInfoQueryKey>;
+
+export const getJettonInfoQueryOptions = <selectData = GetJettonInfoData>(
+    appKit: AppKit,
+    options: GetJettonInfoQueryConfig<selectData> = {},
+): GetJettonInfoQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetJettonInfoOptions];
+            if (!parameters.address) throw new Error('address is required');
+
+            const jettonInfo = await getJettonInfo(appKit, parameters);
+            return jettonInfo;
+        },
+        queryKey: getJettonInfoQueryKey(options),
+    };
+};
+
+export type GetJettonInfoQueryFnData = Compute<Awaited<GetJettonInfoReturnType>>;
+
+export type GetJettonInfoData = GetJettonInfoQueryFnData;
+
+export const getJettonInfoQueryKey = (
+    options: Compute<ExactPartial<GetJettonInfoOptions>> = {},
+): GetJettonInfoQueryKey => {
+    return ['jetton-info', filterQueryOptions(options)] as const;
+};
+
+export type GetJettonInfoQueryKey = readonly ['jetton-info', Compute<ExactPartial<GetJettonInfoOptions>>];
+
+export type GetJettonInfoQueryOptions<selectData = GetJettonInfoData> = QueryOptions<
+    GetJettonInfoQueryFnData,
+    GetJettonInfoErrorType,
+    selectData,
+    GetJettonInfoQueryKey
+>;

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

@@ -0,0 +1,69 @@
+/**
+ * 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 { UserFriendlyAddress } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { getJettonWalletAddress } from '../../actions/jettons/get-jetton-wallet-address';
+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';
+
+export type GetJettonWalletAddressErrorType = Error;
+
+export type GetJettonWalletAddressQueryConfig<selectData = GetJettonWalletAddressData> = Compute<
+    ExactPartial<GetJettonWalletAddressParameters>
+> &
+    QueryParameter<
+        GetJettonWalletAddressQueryFnData,
+        GetJettonWalletAddressErrorType,
+        selectData,
+        GetJettonWalletAddressQueryKey
+    >;
+
+export const getJettonWalletAddressQueryOptions = <selectData = GetJettonWalletAddressData>(
+    appKit: AppKit,
+    options: GetJettonWalletAddressQueryConfig<selectData> = {},
+): GetJettonWalletAddressQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.jettonAddress && options.ownerAddress && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetJettonWalletAddressParameters];
+            if (!parameters.jettonAddress) throw new Error('jettonAddress is required');
+            if (!parameters.ownerAddress) throw new Error('ownerAddress is required');
+
+            const jettonWalletAddress = await getJettonWalletAddress(appKit, parameters);
+            return jettonWalletAddress;
+        },
+        queryKey: getJettonWalletAddressQueryKey(options),
+    };
+};
+
+export type GetJettonWalletAddressQueryFnData = Compute<UserFriendlyAddress>;
+
+export type GetJettonWalletAddressData = GetJettonWalletAddressQueryFnData;
+
+export const getJettonWalletAddressQueryKey = (
+    options: Compute<ExactPartial<GetJettonWalletAddressParameters>> = {},
+): GetJettonWalletAddressQueryKey => {
+    return ['jetton-wallet-address', filterQueryOptions(options)] as const;
+};
+
+export type GetJettonWalletAddressQueryKey = readonly [
+    'jetton-wallet-address',
+    Compute<ExactPartial<GetJettonWalletAddressParameters>>,
+];
+
+export type GetJettonWalletAddressQueryOptions<selectData = GetJettonWalletAddressData> = QueryOptions<
+    GetJettonWalletAddressQueryFnData,
+    GetJettonWalletAddressErrorType,
+    selectData,
+    GetJettonWalletAddressQueryKey
+>;

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

@@ -0,0 +1,59 @@
+/**
+ * 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 { 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 type { GetJettonsByAddressReturnType } from '../../actions/jettons/get-jettons-by-address';
+
+export type GetJettonsErrorType = Error;
+
+export type GetJettonsByAddressData = GetJettonsQueryFnData;
+
+export type GetJettonsByAddressQueryConfig<selectData = GetJettonsByAddressData> = Compute<
+    ExactPartial<GetJettonsByAddressOptions>
+> &
+    QueryParameter<GetJettonsQueryFnData, GetJettonsErrorType, selectData, GetJettonsByAddressQueryKey>;
+
+export const getJettonsByAddressQueryOptions = <selectData = GetJettonsByAddressData>(
+    appKit: AppKit,
+    options: GetJettonsByAddressQueryConfig<selectData> = {},
+): GetJettonsByAddressQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetJettonsByAddressOptions];
+            if (!parameters.address) throw new Error('address is required');
+
+            const jettons = await getJettonsByAddress(appKit, parameters);
+            return jettons;
+        },
+        queryKey: getJettonsByAddressQueryKey(options),
+    };
+};
+
+export type GetJettonsQueryFnData = Compute<Awaited<GetJettonsByAddressReturnType>>;
+
+export const getJettonsByAddressQueryKey = (
+    options: Compute<ExactPartial<GetJettonsByAddressOptions>> = {},
+): GetJettonsByAddressQueryKey => {
+    return ['jettons', filterQueryOptions(options)] as const;
+};
+
+export type GetJettonsByAddressQueryKey = readonly ['jettons', Compute<ExactPartial<GetJettonsByAddressOptions>>];
+
+export type GetJettonsByAddressQueryOptions<selectData = GetJettonsByAddressData> = QueryOptions<
+    GetJettonsQueryFnData,
+    GetJettonsErrorType,
+    selectData,
+    GetJettonsByAddressQueryKey
+>;

package/src/queries/jettons/transfer-jetton.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { transferJetton } from '../../actions/jettons/transfer-jetton';
+import type { TransferJettonParameters, TransferJettonReturnType } from '../../actions/jettons/transfer-jetton';
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type { TransferJettonParameters, TransferJettonReturnType };
+
+export type TransferJettonErrorType = Error;
+
+export type TransferJettonOptions<context = unknown> = MutationParameter<
+    TransferJettonData,
+    TransferJettonErrorType,
+    TransferJettonVariables,
+    context
+>;
+
+export const transferJettonMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: TransferJettonOptions<context> = {},
+): TransferJettonMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return transferJetton(appKit, variables);
+        },
+        mutationKey: ['transferJetton'],
+    };
+};
+
+export type TransferJettonMutationOptions<context = unknown> = MutationOptions<
+    TransferJettonData,
+    TransferJettonErrorType,
+    TransferJettonVariables,
+    context
+>;
+
+export type TransferJettonData = Compute<TransferJettonReturnType>;
+
+export type TransferJettonVariables = TransferJettonParameters;
+
+export type TransferJettonMutate<context = unknown> = (
+    variables: TransferJettonVariables,
+    options?:
+        | Compute<MutateOptions<TransferJettonData, TransferJettonErrorType, Compute<TransferJettonVariables>, context>>
+        | undefined,
+) => void;
+
+export type TransferJettonMutateAsync<context = unknown> = (
+    variables: TransferJettonVariables,
+    options?:
+        | Compute<MutateOptions<TransferJettonData, TransferJettonErrorType, Compute<TransferJettonVariables>, context>>
+        | undefined,
+) => Promise<TransferJettonData>;

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

@@ -0,0 +1,56 @@
+/**
+ * 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 { NFT } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+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';
+
+export type GetNftErrorType = Error;
+
+export type GetNftQueryConfig<selectData = GetNftData> = Compute<ExactPartial<GetNftParameters>> &
+    QueryParameter<GetNftQueryFnData, GetNftErrorType, selectData, GetNftQueryKey>;
+
+export const getNftQueryOptions = <selectData = GetNftData>(
+    appKit: AppKit,
+    options: GetNftQueryConfig<selectData> = {},
+): GetNftQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetNftParameters];
+            if (!parameters.address) throw new Error('address is required');
+
+            const nft = await getNft(appKit, parameters);
+            return nft;
+        },
+        queryKey: getNftQueryKey(options),
+    };
+};
+
+export type GetNftQueryFnData = Compute<NFT | null>;
+
+export type GetNftData = GetNftQueryFnData;
+
+export const getNftQueryKey = (options: Compute<ExactPartial<GetNftParameters>> = {}): GetNftQueryKey => {
+    return ['nft', filterQueryOptions(options)] as const;
+};
+
+export type GetNftQueryKey = readonly ['nft', Compute<ExactPartial<GetNftParameters>>];
+
+export type GetNftQueryOptions<selectData = GetNftData> = QueryOptions<
+    GetNftQueryFnData,
+    GetNftErrorType,
+    selectData,
+    GetNftQueryKey
+>;

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

@@ -0,0 +1,59 @@
+/**
+ * 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 { AppKit } from '../../core/app-kit';
+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 type { GetNftsByAddressReturnType } from '../../actions/nft/get-nfts-by-address';
+
+export type GetNFTsErrorType = Error;
+
+export type GetNFTsByAddressData = GetNFTsQueryFnData;
+
+export type GetNFTsByAddressQueryConfig<selectData = GetNFTsByAddressData> = Compute<
+    ExactPartial<GetNftsByAddressOptions>
+> &
+    QueryParameter<GetNFTsQueryFnData, GetNFTsErrorType, selectData, GetNFTsByAddressQueryKey>;
+
+export const getNFTsByAddressQueryOptions = <selectData = GetNFTsByAddressData>(
+    appKit: AppKit,
+    options: GetNFTsByAddressQueryConfig<selectData> = {},
+): GetNFTsByAddressQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetNftsByAddressOptions];
+            if (!parameters.address) throw new Error('address is required');
+
+            const nfts = await getNftsByAddress(appKit, parameters);
+            return nfts;
+        },
+        queryKey: getNFTsByAddressQueryKey(options),
+    };
+};
+
+export type GetNFTsQueryFnData = Compute<Awaited<GetNftsByAddressReturnType>>;
+
+export const getNFTsByAddressQueryKey = (
+    options: Compute<ExactPartial<GetNftsByAddressOptions>> = {},
+): GetNFTsByAddressQueryKey => {
+    return ['nfts', filterQueryOptions(options)] as const;
+};
+
+export type GetNFTsByAddressQueryKey = readonly ['nfts', Compute<ExactPartial<GetNftsByAddressOptions>>];
+
+export type GetNFTsByAddressQueryOptions<selectData = GetNFTsByAddressData> = QueryOptions<
+    GetNFTsQueryFnData,
+    GetNFTsErrorType,
+    selectData,
+    GetNFTsByAddressQueryKey
+>;