@ton/appkit 0.0.1-alpha.2 → 0.0.2

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
+>;

package/src/queries/nft/transfer-nft.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 { transferNft } from '../../actions/nft/transfer-nft';
+import type { TransferNftParameters, TransferNftReturnType } from '../../actions/nft/transfer-nft';
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type { TransferNftParameters, TransferNftReturnType };
+
+export type TransferNftErrorType = Error;
+
+export type TransferNftOptions<context = unknown> = MutationParameter<
+    TransferNftData,
+    TransferNftErrorType,
+    TransferNftVariables,
+    context
+>;
+
+export const transferNftMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: TransferNftOptions<context> = {},
+): TransferNftMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return transferNft(appKit, variables);
+        },
+        mutationKey: ['transferNft'],
+    };
+};
+
+export type TransferNftMutationOptions<context = unknown> = MutationOptions<
+    TransferNftData,
+    TransferNftErrorType,
+    TransferNftVariables,
+    context
+>;
+
+export type TransferNftData = Compute<TransferNftReturnType>;
+
+export type TransferNftVariables = TransferNftParameters;
+
+export type TransferNftMutate<context = unknown> = (
+    variables: TransferNftVariables,
+    options?:
+        | Compute<MutateOptions<TransferNftData, TransferNftErrorType, Compute<TransferNftVariables>, context>>
+        | undefined,
+) => void;
+
+export type TransferNftMutateAsync<context = unknown> = (
+    variables: TransferNftVariables,
+    options?:
+        | Compute<MutateOptions<TransferNftData, TransferNftErrorType, Compute<TransferNftVariables>, context>>
+        | undefined,
+) => Promise<TransferNftData>;

package/src/queries/signing/sign-binary.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 { signBinary } from '../../actions/signing/sign-binary';
+import type { SignBinaryParameters, SignBinaryReturnType } from '../../actions/signing/sign-binary';
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type SignBinaryErrorType = Error;
+
+export type SignBinaryOptions<context = unknown> = MutationParameter<
+    SignBinaryData,
+    SignBinaryErrorType,
+    SignBinaryVariables,
+    context
+>;
+
+export const signBinaryMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: SignBinaryOptions<context> = {},
+): SignBinaryMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return signBinary(appKit, variables);
+        },
+        mutationKey: ['signBinary'],
+    };
+};
+
+export type SignBinaryMutationOptions<context = unknown> = MutationOptions<
+    SignBinaryData,
+    SignBinaryErrorType,
+    SignBinaryVariables,
+    context
+>;
+
+export type SignBinaryData = Compute<SignBinaryReturnType>;
+
+export type SignBinaryVariables = SignBinaryParameters;
+
+export type SignBinaryMutate<context = unknown> = (
+    variables: SignBinaryVariables,
+    options?:
+        | Compute<MutateOptions<SignBinaryData, SignBinaryErrorType, Compute<SignBinaryVariables>, context>>
+        | undefined,
+) => void;
+
+export type SignBinaryMutateAsync<context = unknown> = (
+    variables: SignBinaryVariables,
+    options?:
+        | Compute<MutateOptions<SignBinaryData, SignBinaryErrorType, Compute<SignBinaryVariables>, context>>
+        | undefined,
+) => Promise<SignBinaryData>;

package/src/queries/signing/sign-cell.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 { signCell } from '../../actions/signing/sign-cell';
+import type { SignCellParameters, SignCellReturnType } from '../../actions/signing/sign-cell';
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type SignCellErrorType = Error;
+
+export type SignCellOptions<context = unknown> = MutationParameter<
+    SignCellData,
+    SignCellErrorType,
+    SignCellVariables,
+    context
+>;
+
+export const signCellMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: SignCellOptions<context> = {},
+): SignCellMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return signCell(appKit, variables);
+        },
+        mutationKey: ['signCell'],
+    };
+};
+
+export type SignCellMutationOptions<context = unknown> = MutationOptions<
+    SignCellData,
+    SignCellErrorType,
+    SignCellVariables,
+    context
+>;
+
+export type SignCellData = Compute<SignCellReturnType>;
+
+export type SignCellVariables = SignCellParameters;
+
+export type SignCellMutate<context = unknown> = (
+    variables: SignCellVariables,
+    options?: Compute<MutateOptions<SignCellData, SignCellErrorType, Compute<SignCellVariables>, context>> | undefined,
+) => void;
+
+export type SignCellMutateAsync<context = unknown> = (
+    variables: SignCellVariables,
+    options?: Compute<MutateOptions<SignCellData, SignCellErrorType, Compute<SignCellVariables>, context>> | undefined,
+) => Promise<SignCellData>;

package/src/queries/signing/sign-text.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 { signText } from '../../actions/signing/sign-text';
+import type { SignTextParameters, SignTextReturnType } from '../../actions/signing/sign-text';
+import type { AppKit } from '../../core/app-kit';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type SignTextErrorType = Error;
+
+export type SignTextOptions<context = unknown> = MutationParameter<
+    SignTextData,
+    SignTextErrorType,
+    SignTextVariables,
+    context
+>;
+
+export const signTextMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: SignTextOptions<context> = {},
+): SignTextMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return signText(appKit, variables);
+        },
+        mutationKey: ['signText'],
+    };
+};
+
+export type SignTextMutationOptions<context = unknown> = MutationOptions<
+    SignTextData,
+    SignTextErrorType,
+    SignTextVariables,
+    context
+>;
+
+export type SignTextData = Compute<SignTextReturnType>;
+
+export type SignTextVariables = SignTextParameters;
+
+export type SignTextMutate<context = unknown> = (
+    variables: SignTextVariables,
+    options?: Compute<MutateOptions<SignTextData, SignTextErrorType, Compute<SignTextVariables>, context>> | undefined,
+) => void;
+
+export type SignTextMutateAsync<context = unknown> = (
+    variables: SignTextVariables,
+    options?: Compute<MutateOptions<SignTextData, SignTextErrorType, Compute<SignTextVariables>, context>> | undefined,
+) => Promise<SignTextData>;