@ton/appkit 0.0.1-alpha.2 → 0.0.2

package/src/core/emitter/services/emitter.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { EventListener, AppKitEvent, EventPayload } from '../types/events';
+
+export class Emitter<Events extends { [K in keyof Events]: EventPayload }> {
+    private listeners = new Map<keyof Events, Set<unknown>>();
+
+    emit<K extends keyof Events>(type: K, payload: Events[K], source: string): void {
+        const event: AppKitEvent<Events[K]> = {
+            type: type as string,
+            payload,
+            source,
+            timestamp: Date.now(),
+        };
+
+        const listeners = this.listeners.get(type);
+
+        if (listeners) {
+            listeners.forEach((listener) => {
+                (listener as EventListener<Events[K]>)(event);
+            });
+        }
+    }
+
+    on<K extends keyof Events>(type: K, listener: EventListener<Events[K]>): () => void {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, new Set());
+        }
+
+        this.listeners.get(type)!.add(listener as unknown);
+
+        return () => this.off(type, listener);
+    }
+
+    off<K extends keyof Events>(type: K, listener: EventListener<Events[K]>): void {
+        this.listeners.get(type)?.delete(listener as unknown);
+    }
+
+    once<K extends keyof Events>(type: K, listener: EventListener<Events[K]>): () => void {
+        const wrapper = (event: AppKitEvent<Events[K]>) => {
+            this.off(type, wrapper);
+            listener(event);
+        };
+
+        return this.on(type, wrapper);
+    }
+}

package/src/core/emitter/types/events.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 type EventPayload = object;
+
+export interface AppKitEvent<T extends EventPayload = EventPayload> {
+    type: string;
+    payload: T;
+    source: string;
+    timestamp: number;
+}
+
+export type EventListener<T extends EventPayload = EventPayload> = (event: AppKitEvent<T>) => void;

package/src/core/wallets-manager/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 { WalletsManager } from './services/wallets-manager';

package/src/core/wallets-manager/services/wallets-manager.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 { AppKitEmitter } from '../../../core/app-kit';
+import { WALLETS_EVENTS } from '../../../core/app-kit';
+import type { WalletInterface } from '../../../types/wallet';
+
+/**
+ * Manages connected wallets.
+ */
+export class WalletsManager {
+    private _wallets: WalletInterface[];
+    private _selectedWalletId: string | null;
+    private emitter: AppKitEmitter;
+
+    constructor(emitter: AppKitEmitter) {
+        this._wallets = [];
+        this._selectedWalletId = null;
+        this.emitter = emitter;
+    }
+
+    /**
+     * All connected wallets
+     */
+    get wallets(): WalletInterface[] {
+        return this._wallets;
+    }
+
+    /**
+     * Selected wallet id
+     */
+    get selectedWalletId(): string | null {
+        return this._selectedWalletId;
+    }
+
+    /**
+     * Selected wallet
+     */
+    get selectedWallet(): WalletInterface | null {
+        if (!this._selectedWalletId) {
+            return null;
+        }
+
+        return this._wallets.find((wallet) => wallet.getWalletId() === this._selectedWalletId) ?? null;
+    }
+
+    /**
+     * Set selected wallet id
+     */
+    setSelectedWalletId(id: string | null): void {
+        this._selectedWalletId = id;
+    }
+
+    /**
+     * Set connected wallets
+     * Automatically handles selected wallet state
+     */
+    setWallets(wallets: WalletInterface[]): void {
+        this._wallets = wallets;
+
+        // If currently selected wallet is still in the new list, keep it
+        if (this._selectedWalletId && wallets.some((w) => w.getWalletId() === this._selectedWalletId)) {
+            return;
+        }
+
+        // If list is not empty, auto-select the first one
+        if (wallets.length > 0) {
+            this._selectedWalletId = wallets[0].getWalletId();
+            this.emitter.emit(
+                WALLETS_EVENTS.SELECTION_CHANGED,
+                { walletId: this._selectedWalletId },
+                'wallets-manager',
+            );
+
+            return;
+        }
+
+        // Otherwise clear selection
+        this._selectedWalletId = null;
+        this.emitter.emit(WALLETS_EVENTS.SELECTION_CHANGED, { walletId: null }, 'wallets-manager');
+    }
+}

package/src/index.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.
+ *
+ */
+
+/**
+ * AppKit - Core wallet management for TON dApps
+ *
+ * This is the main entry point for AppKit. It provides provider-agnostic
+ * wallet management functionality.
+ *
+ * For TonConnect support, import from '@ton/appkit/tonconnect' separately.
+ * This allows tree-shaking for users who don't need TonConnect.
+ *
+ * @example
+ * ```ts
+ * // Core AppKit (provider-agnostic)
+ * import { AppKit } from '@ton/appkit';
+ *
+ * // TonConnect feature (optional, for tree-shaking)
+ * import { TonConnectConnector } from '@ton/appkit/tonconnect';
+ * ```
+ */
+
+// Core
+export * from './core/app-kit';
+export * from './core/emitter';
+export * from './connectors/tonconnect';
+
+export * from './swap';
+
+// Actions
+export * from './actions';
+
+// Types
+export * from './types/connector';
+export * from './types/balance';
+export * from './types/wallet';
+export * from './types/query';
+export * from './types/utils';
+export * from './types/network';
+export * from './types/jetton';
+export * from './types/nft';
+export * from './types/transaction';
+export * from './types/primitives';
+export * from './types/signing';
+
+// Utils
+export * from './utils';

package/src/queries/balances/get-balance-by-address.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 { 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 type { GetBalanceByAddressReturnType } from '../../actions/balances/get-balance-by-address';
+
+export type GetBalanceErrorType = Error;
+
+export type GetBalanceByAddressData = GetBalanceQueryFnData;
+
+export type GetBalanceByAddressQueryConfig<selectData = GetBalanceByAddressData> = Compute<
+    ExactPartial<GetBalanceByAddressOptions>
+> &
+    QueryParameter<GetBalanceQueryFnData, GetBalanceErrorType, selectData, GetBalanceByAddressQueryKey>;
+
+export const getBalanceByAddressQueryOptions = <selectData = GetBalanceByAddressData>(
+    appKit: AppKit,
+    options: GetBalanceByAddressQueryConfig<selectData> = {},
+): GetBalanceByAddressQueryOptions<selectData> => {
+    return {
+        ...options.query,
+        enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+        queryFn: async (context) => {
+            const [, parameters] = context.queryKey as [string, GetBalanceByAddressOptions];
+            if (!parameters.address) throw new Error('address is required');
+            const balance = await getBalanceByAddress(appKit, parameters);
+            return balance ?? null;
+        },
+        queryKey: getBalanceByAddressQueryKey(options),
+    };
+};
+
+export type GetBalanceQueryFnData = Compute<Awaited<GetBalanceByAddressReturnType>>;
+
+export const getBalanceByAddressQueryKey = (
+    options: Compute<ExactPartial<GetBalanceByAddressOptions>> = {},
+): GetBalanceByAddressQueryKey => {
+    return ['balance', filterQueryOptions(options)] as const;
+};
+
+export type GetBalanceByAddressQueryKey = readonly ['balance', Compute<ExactPartial<GetBalanceByAddressOptions>>];
+
+export type GetBalanceByAddressQueryOptions<selectData = GetBalanceByAddressData> = QueryOptions<
+    GetBalanceQueryFnData,
+    GetBalanceErrorType,
+    selectData,
+    GetBalanceByAddressQueryKey
+>;

package/src/queries/connectors/connect.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 type { MutateOptions, MutationOptions } from '@tanstack/query-core';
+
+import type { AppKit } from '../../core/app-kit';
+import { connect } from '../../actions/connectors/connect';
+import type { ConnectParameters, ConnectReturnType } from '../../actions/connectors/connect';
+import type { MutationParameter } from '../../types/query';
+import type { Compute } from '../../types/utils';
+
+export type { ConnectParameters, ConnectReturnType };
+
+export type ConnectErrorType = Error;
+
+export type ConnectOptions<context = unknown> = MutationParameter<
+    ConnectData,
+    ConnectErrorType,
+    ConnectVariables,
+    context
+>;
+
+export const connectMutationOptions = <context = unknown>(
+    appKit: AppKit,
+    options: ConnectOptions<context> = {},
+): ConnectMutationOptions<context> => {
+    return {
+        ...options.mutation,
+        mutationFn(variables) {
+            return connect(appKit, variables);
+        },
+        mutationKey: ['connect'],
+    };
+};
+
+export type ConnectMutationOptions<context = unknown> = MutationOptions<
+    ConnectData,
+    ConnectErrorType,
+    ConnectVariables,
+    context
+>;
+
+export type ConnectData = Compute<ConnectReturnType>;
+
+export type ConnectVariables = ConnectParameters;
+
+export type ConnectMutate<context = unknown> = (
+    variables: ConnectVariables,
+    options?: Compute<MutateOptions<ConnectData, ConnectErrorType, Compute<ConnectVariables>, context>> | undefined,
+) => void;
+
+export type ConnectMutateAsync<context = unknown> = (
+    variables: ConnectVariables,
+    options?: Compute<MutateOptions<ConnectData, ConnectErrorType, Compute<ConnectVariables>, context>> | undefined,
+) => Promise<ConnectData>;

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,190 @@
+/**
+ * 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';
+export {
+    getTransactionStatusQueryOptions,
+    type GetTransactionStatusData,
+    type GetTransactionStatusErrorType,
+    type GetTransactionStatusParameters,
+    type GetTransactionStatusReturnType,
+    type GetTransactionStatusQueryConfig,
+    type GetTransactionStatusQueryOptions,
+} from './transaction/get-transaction-status';

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