@ton/appkit 0.0.1-alpha.2 → 0.0.1

package/src/actions/swap/build-swap-transaction.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { SwapParams } from '../../swap';
+import type { TransactionRequest } from '../../types/transaction';
+import type { AppKit } from '../../core/app-kit';
+
+export type BuildSwapTransactionOptions<T = unknown> = SwapParams<T>;
+
+export type BuildSwapTransactionReturnType = Promise<TransactionRequest>;
+
+/**
+ * Build swap transaction
+ */
+export const buildSwapTransaction = async <T = unknown>(
+    appKit: AppKit,
+    options: BuildSwapTransactionOptions<T>,
+): BuildSwapTransactionReturnType => {
+    return appKit.swapManager.buildSwapTransaction(options);
+};

package/src/actions/swap/get-swap-manager.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { SwapManager } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export type GetSwapManagerReturnType = SwapManager;
+
+/**
+ * Get swap manager instance
+ */
+export const getSwapManager = (appKit: AppKit): GetSwapManagerReturnType => {
+    return appKit.swapManager;
+};

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

@@ -0,0 +1,27 @@
+/**
+ * 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 { SwapQuote, SwapQuoteParams } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export type GetSwapQuoteOptions<T = unknown> = SwapQuoteParams<T> & {
+    providerId?: string;
+};
+
+export type GetSwapQuoteReturnType = Promise<SwapQuote>;
+
+/**
+ * Get swap quote
+ */
+export const getSwapQuote = async <T = unknown>(
+    appKit: AppKit,
+    options: GetSwapQuoteOptions<T>,
+): GetSwapQuoteReturnType => {
+    return appKit.swapManager.getQuote(options, options.providerId);
+};

package/src/actions/transaction/create-transfer-ton-transaction.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 { createCommentPayloadBase64, parseUnits } from '@ton/walletkit';
+
+import type { TransactionRequest, TransactionRequestMessage } from '../../types/transaction';
+import type { AppKit } from '../../core/app-kit';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface CreateTransferTonTransactionParameters {
+    /** Recipient address */
+    recipientAddress: string;
+    /** Amount in TONs */
+    amount: string;
+    /** Human-readable text comment (will be converted to payload) */
+    comment?: string;
+    /** Message payload data encoded in Base64 (overrides comment if provided) */
+    payload?: string;
+    /** Initial state for deploying a new contract, encoded in Base64 */
+    stateInit?: string;
+}
+
+export type CreateTransferTonTransactionReturnType = TransactionRequest;
+
+/**
+ * Create a TON transfer transaction request
+ */
+export const createTransferTonTransaction = (
+    appKit: AppKit,
+    parameters: CreateTransferTonTransactionParameters,
+): CreateTransferTonTransactionReturnType => {
+    const { recipientAddress, amount, comment, payload, stateInit } = parameters;
+
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    const message: TransactionRequestMessage = {
+        address: recipientAddress,
+        amount: parseUnits(amount, 9).toString(),
+        stateInit,
+    };
+
+    // Payload takes priority, otherwise use comment
+    if (payload) {
+        message.payload = payload;
+    } else if (comment) {
+        message.payload = createCommentPayloadBase64(comment);
+    }
+
+    return {
+        messages: [message],
+        network: wallet.getNetwork(),
+        fromAddress: wallet.getAddress(),
+    };
+};

package/src/actions/transaction/send-transaction.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { SendTransactionResponse } from '@ton/walletkit';
+
+import type { TransactionRequest } from '../../types/transaction';
+import type { AppKit } from '../../core/app-kit';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export type SendTransactionParameters = TransactionRequest;
+
+export type SendTransactionReturnType = SendTransactionResponse;
+
+export type SendTransactionErrorType = Error;
+
+/**
+ * Send transaction
+ */
+export const sendTransaction = async (
+    appKit: AppKit,
+    parameters: SendTransactionParameters,
+): Promise<SendTransactionReturnType> => {
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    return wallet.sendTransaction(parameters);
+};

package/src/actions/transaction/transfer-ton.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { SendTransactionResponse } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { createTransferTonTransaction } from './create-transfer-ton-transaction';
+import type { CreateTransferTonTransactionParameters } from './create-transfer-ton-transaction';
+import { sendTransaction } from './send-transaction';
+
+export type TransferTonParameters = CreateTransferTonTransactionParameters;
+
+export type TransferTonReturnType = SendTransactionResponse;
+
+export type TransferTonErrorType = Error;
+
+/**
+ * Transfer TON - creates and sends a TON transfer transaction
+ */
+export const transferTon = async (
+    appKit: AppKit,
+    parameters: TransferTonParameters,
+): Promise<TransferTonReturnType> => {
+    const transaction = createTransferTonTransaction(appKit, parameters);
+
+    return sendTransaction(appKit, transaction);
+};

package/src/actions/wallets/get-connected-wallets.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 type { WalletInterface } from '../../types/wallet';
+
+export type GetConnectedWalletsReturnType = readonly WalletInterface[];
+
+/**
+ * Get connected wallets
+ */
+export const getConnectedWallets = (appKit: AppKit): GetConnectedWalletsReturnType => {
+    return appKit.walletsManager.wallets;
+};

package/src/actions/wallets/get-selected-wallet.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 type { WalletInterface } from '../../types/wallet';
+
+export type GetSelectedWalletReturnType = WalletInterface | null;
+
+/**
+ * Get currently selected wallet
+ */
+export const getSelectedWallet = (appKit: AppKit): GetSelectedWalletReturnType => {
+    return appKit.walletsManager.selectedWallet;
+};

package/src/actions/wallets/set-selected-wallet-id.ts

@@ -0,0 +1,25 @@
+/**
+ * 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';
+
+export interface SetSelectedWalletIdParameters {
+    walletId: string | null;
+}
+
+export type SetSelectedWalletIdReturnType = void;
+
+/**
+ * Set selected wallet
+ */
+export const setSelectedWalletId = (
+    appKit: AppKit,
+    parameters: SetSelectedWalletIdParameters,
+): SetSelectedWalletIdReturnType => {
+    appKit.walletsManager.setSelectedWalletId(parameters.walletId);
+};

package/src/actions/wallets/watch-connected-wallets.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { WALLETS_EVENTS } from '../../core/app-kit';
+import type { WalletInterface } from '../../types/wallet';
+
+export type WatchConnectedWalletsParameters = {
+    onChange: (wallets: WalletInterface[]) => void;
+};
+
+export type WatchConnectedWalletsReturnType = () => void;
+
+/**
+ * Watch connected wallets
+ */
+export const watchConnectedWallets = (
+    appKit: AppKit,
+    parameters: WatchConnectedWalletsParameters,
+): WatchConnectedWalletsReturnType => {
+    const { onChange } = parameters;
+
+    const unsubscribe = appKit.emitter.on(WALLETS_EVENTS.UPDATED, (data) => {
+        onChange(data.payload.wallets);
+    });
+
+    return unsubscribe;
+};

package/src/actions/wallets/watch-selected-wallet.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { WALLETS_EVENTS } from '../../core/app-kit';
+import { getSelectedWallet } from '../../actions';
+import type { WalletInterface } from '../../types/wallet';
+
+export interface WatchSelectedWalletParameters {
+    onChange: (wallet: WalletInterface | null) => void;
+}
+
+export type WatchSelectedWalletReturnType = () => void;
+
+/**
+ * Watch selected wallet
+ */
+export const watchSelectedWallet = (
+    appKit: AppKit,
+    parameters: WatchSelectedWalletParameters,
+): WatchSelectedWalletReturnType => {
+    const { onChange } = parameters;
+
+    const unsubscribe = appKit.emitter.on(WALLETS_EVENTS.SELECTION_CHANGED, () => {
+        const wallet = getSelectedWallet(appKit);
+        onChange(wallet ?? null);
+    });
+
+    return unsubscribe;
+};

package/src/connectors/tonconnect/adapters/ton-connect-wallet-adapter.ts

@@ -0,0 +1,161 @@
+/**
+ * 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 { Address } from '@ton/core';
+import type { Wallet as TonConnectWallet } from '@tonconnect/sdk';
+import { CHAIN } from '@tonconnect/sdk';
+import type { SignDataPayload as TonConnectSignDataPayload } from '@tonconnect/sdk';
+import type { SendTransactionResponse, UserFriendlyAddress, Hex } from '@ton/walletkit';
+import { Network, asHex, createWalletId } from '@ton/walletkit';
+import type { TonConnectUI } from '@tonconnect/ui';
+
+import type { TransactionRequest } from '../../../types/transaction';
+import type { Base64String } from '../../../types/primitives';
+import { getValidUntil } from '../utils/transaction';
+import type { WalletInterface } from '../../../types/wallet';
+import type { SignDataRequest, SignDataResponse } from '../../../types/signing';
+
+/**
+ * Configuration for TonConnectWalletAdapter
+ */
+export interface TonConnectWalletAdapterConfig {
+    connectorId: string;
+    tonConnectWallet: TonConnectWallet;
+    tonConnectUI: TonConnectUI;
+}
+
+/**
+ * Minimal adapter that makes TonConnect wallet compatible with WalletInterface.
+ * Only implements identity and signing methods - data fetching is done via actions.
+ */
+export class TonConnectWalletAdapter implements WalletInterface {
+    public readonly tonConnectWallet: TonConnectWallet;
+    public readonly tonConnectUI: TonConnectUI;
+    public readonly connectorId: string;
+
+    constructor(config: TonConnectWalletAdapterConfig) {
+        this.tonConnectWallet = config.tonConnectWallet;
+        this.tonConnectUI = config.tonConnectUI;
+        this.connectorId = config.connectorId;
+    }
+
+    // ==========================================
+    // Identity
+    // ==========================================
+
+    getAddress(): UserFriendlyAddress {
+        const account = this.tonConnectWallet.account;
+        if (!account) {
+            throw new Error('Wallet not connected');
+        }
+        return Address.parse(account.address).toString();
+    }
+
+    getPublicKey(): Hex {
+        const account = this.tonConnectWallet.account;
+        if (account?.publicKey) {
+            return asHex(`0x${account.publicKey}`);
+        }
+        throw new Error('Public key not found');
+    }
+
+    getNetwork(): Network {
+        const account = this.tonConnectWallet.account;
+        return Network.custom(account?.chain ?? Network.testnet().chainId);
+    }
+
+    getWalletId(): string {
+        return createWalletId(this.getNetwork(), this.getAddress());
+    }
+
+    // ==========================================
+    // Signing / Transactions
+    // ==========================================
+
+    async sendTransaction(request: TransactionRequest): Promise<SendTransactionResponse> {
+        const transaction = {
+            validUntil: request.validUntil || getValidUntil(),
+            messages: request.messages.map((msg) => ({
+                address: msg.address,
+                amount: String(msg.amount),
+                payload: msg.payload,
+                stateInit: msg.stateInit,
+            })),
+            network: (request.network?.chainId as CHAIN) ?? this.tonConnectWallet.account?.chain,
+        };
+
+        const result = await this.tonConnectUI.sendTransaction(transaction);
+
+        return { boc: result.boc as Base64String };
+    }
+
+    async signData(payload: SignDataRequest): Promise<SignDataResponse> {
+        const result = await this.tonConnectUI.signData(this.mapSignDataRequest(payload));
+
+        return {
+            payload,
+            address: result.address,
+            timestamp: result.timestamp,
+            domain: result.domain,
+            signature: result.signature,
+        };
+    }
+
+    // ==========================================
+    // Private helpers
+    // ==========================================
+
+    private mapNetworkToChain(network: Network): CHAIN {
+        switch (network.chainId) {
+            case Network.mainnet().chainId:
+                return CHAIN.MAINNET;
+            case Network.testnet().chainId:
+                return CHAIN.TESTNET;
+            default:
+                return network.chainId as CHAIN;
+        }
+    }
+
+    private mapSignDataRequest(request: SignDataRequest): TonConnectSignDataPayload {
+        const chainId = request.network
+            ? this.mapNetworkToChain(request.network)
+            : (this.getNetwork().chainId as CHAIN);
+
+        const { data } = request;
+
+        if (data.type === 'text') {
+            return {
+                type: 'text',
+                text: data.value.content,
+                network: chainId,
+                from: request.from,
+            };
+        }
+
+        if (data.type === 'binary') {
+            return {
+                type: 'binary',
+                bytes: data.value.content,
+                network: chainId,
+                from: request.from,
+            };
+        }
+
+        if (data.type === 'cell') {
+            return {
+                type: 'cell',
+                cell: data.value.content,
+                schema: data.value.schema,
+                network: chainId,
+                from: request.from,
+            };
+        }
+
+        throw new Error('Unsupported payload type');
+    }
+}

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

@@ -0,0 +1,99 @@
+/**
+ * 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 { TonConnectUI } from '@tonconnect/ui';
+import type { TonConnectUiCreateOptions } from '@tonconnect/ui';
+
+import { TonConnectWalletAdapter } from '../adapters/ton-connect-wallet-adapter';
+import { CONNECTOR_EVENTS } from '../../../core/app-kit';
+import type { Connector, ConnectorMetadata } from '../../../types/connector';
+import type { WalletInterface } from '../../../types/wallet';
+import type { AppKitEmitter } from '../../../core/app-kit';
+import { TONCONNECT_DEFAULT_CONNECTOR_ID } from '../constants/id';
+
+export interface TonConnectConnectorConfig {
+    id?: string;
+    metadata?: ConnectorMetadata;
+    tonConnectOptions?: TonConnectUiCreateOptions;
+    tonConnectUI?: TonConnectUI;
+}
+
+export class TonConnectConnector implements Connector {
+    readonly id: string;
+    readonly type = 'tonconnect';
+    readonly metadata: ConnectorMetadata;
+    readonly tonConnectUI: TonConnectUI;
+
+    private emitter: AppKitEmitter | null = null;
+    private unsubscribeTonConnect: (() => void) | null = null;
+
+    constructor(config: TonConnectConnectorConfig) {
+        if (config.tonConnectOptions && config.tonConnectUI) {
+            // eslint-disable-next-line no-console
+            console.warn(
+                'TonConnectConnector: both tonConnectOptions and tonConnectUI are provided, using tonConnectUI',
+            );
+        }
+
+        this.id = config.id ?? TONCONNECT_DEFAULT_CONNECTOR_ID;
+        this.tonConnectUI = config?.tonConnectUI ?? new TonConnectUI(config.tonConnectOptions);
+        this.metadata = {
+            name: 'TonConnect',
+            iconUrl: 'https://avatars.githubusercontent.com/u/113980577',
+            ...config.metadata,
+        };
+    }
+
+    async initialize(emitter: AppKitEmitter): Promise<void> {
+        this.emitter = emitter;
+
+        // Subscribe to TonConnect status changes
+        this.unsubscribeTonConnect = this.tonConnectUI.onStatusChange((wallet) => {
+            const wallets = this.getConnectedWallets();
+
+            if (wallet) {
+                this.emitter?.emit(CONNECTOR_EVENTS.CONNECTED, { wallets, connectorId: this.id }, this.id);
+            } else {
+                this.emitter?.emit(CONNECTOR_EVENTS.DISCONNECTED, { connectorId: this.id }, this.id);
+            }
+        });
+
+        // Restore existing connection
+        await this.tonConnectUI.connector.restoreConnection();
+    }
+
+    destroy(): void {
+        this.unsubscribeTonConnect?.();
+        this.unsubscribeTonConnect = null;
+        this.emitter = null;
+    }
+
+    async connectWallet(): Promise<void> {
+        await this.tonConnectUI.openModal();
+    }
+
+    async disconnectWallet(): Promise<void> {
+        await this.tonConnectUI.disconnect();
+    }
+
+    getConnectedWallets(): WalletInterface[] {
+        if (this.tonConnectUI.connected && this.tonConnectUI.wallet) {
+            const wallet = this.tonConnectUI.wallet;
+
+            const walletAdapter = new TonConnectWalletAdapter({
+                connectorId: this.id,
+                tonConnectWallet: wallet,
+                tonConnectUI: this.tonConnectUI,
+            });
+
+            return [walletAdapter];
+        }
+
+        return [];
+    }
+}

package/src/connectors/tonconnect/constants/id.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 const TONCONNECT_DEFAULT_CONNECTOR_ID = 'tonconnect';

package/src/connectors/tonconnect/index.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ *
+ */
+
+/**
+ * TonConnect Feature Entry Point
+ *
+ * This module contains all TonConnect-related functionality.
+ * Import from '@ton/appkit/tonconnect' to use TonConnect features.
+ *
+ * This is a separate entry point to allow tree-shaking for users
+ * who don't need TonConnect functionality.
+ *
+ * @example
+ * ```ts
+ * import { TonConnectConnector, TonConnectWalletWrapper } from '@ton/appkit/tonconnect';
+ * ```
+ */
+
+// Adapter exports
+export { TonConnectWalletAdapter } from './adapters/ton-connect-wallet-adapter';
+export type { TonConnectWalletAdapterConfig } from './adapters/ton-connect-wallet-adapter';
+
+// Connector exports
+export { TonConnectConnector } from './connectors/ton-connect-connector';
+export { TONCONNECT_DEFAULT_CONNECTOR_ID } from './constants/id';
+export type { TonConnectConnectorConfig } from './connectors/ton-connect-connector';