@ton/appkit 0.0.1-alpha.2 → 0.0.2

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

@@ -0,0 +1,152 @@
+/**
+ * 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 type { SignDataPayload as TonConnectSignDataPayload } from '@tonconnect/sdk';
+import type { SendTransactionResponse, UserFriendlyAddress, Hex } from '@ton/walletkit';
+import { Network, asHex, createWalletId, getNormalizedExtMessageHash } 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 ?? this.tonConnectWallet.account?.chain,
+        };
+
+        const result = await this.tonConnectUI.sendTransaction(transaction);
+        const { hash, boc: normalizedBoc } = getNormalizedExtMessageHash(result.boc);
+
+        return {
+            boc: result.boc as Base64String,
+            normalizedBoc,
+            normalizedHash: hash,
+        };
+    }
+
+    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 mapSignDataRequest(request: SignDataRequest): TonConnectSignDataPayload {
+        const chainId = request.network?.chainId ?? this.getNetwork().chainId;
+
+        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';

package/src/connectors/tonconnect/utils/transaction.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 { SendTransactionRequest } from '@tonconnect/sdk';
+
+import type { TransactionRequest, TransactionRequestMessage } from '../../../types/transaction';
+
+/**
+ * Default transaction validity duration in seconds (5 minutes)
+ */
+export const DEFAULT_TRANSACTION_VALIDITY_SECONDS = 300;
+
+/**
+ * Convert TonWalletKit TransactionRequest to TonConnect SendTransactionRequest format
+ */
+export function toTonConnectTransaction(request: TransactionRequest): SendTransactionRequest {
+    return {
+        validUntil: request.validUntil ?? Math.floor(Date.now() / 1000) + DEFAULT_TRANSACTION_VALIDITY_SECONDS,
+        messages: request.messages.map(toTonConnectMessage),
+    };
+}
+
+/**
+ * Convert a single TransactionRequestMessage to TonConnect message format
+ */
+export function toTonConnectMessage(msg: TransactionRequestMessage): {
+    address: string;
+    amount: string;
+    payload?: string;
+    stateInit?: string;
+} {
+    return {
+        address: msg.address,
+        amount: String(msg.amount),
+        payload: msg.payload,
+        stateInit: msg.stateInit,
+    };
+}
+
+/**
+ * Get current timestamp plus validity duration
+ */
+export function getValidUntil(validitySeconds = DEFAULT_TRANSACTION_VALIDITY_SECONDS): number {
+    return Math.floor(Date.now() / 1000) + validitySeconds;
+}

package/src/core/app-kit/constants/events.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ */
+
+/**
+ * Connector events
+ */
+export const CONNECTOR_EVENTS = {
+    CONNECTED: 'connector:connected',
+    DISCONNECTED: 'connector:disconnected',
+} as const;
+
+/**
+ * Wallet events
+ */
+export const WALLETS_EVENTS = {
+    UPDATED: 'wallets:updated',
+    SELECTION_CHANGED: 'wallets:selection-changed',
+} as const;
+
+/**
+ * Networks events
+ */
+export const NETWORKS_EVENTS = {
+    UPDATED: 'networks:updated',
+} as const;
+
+/**
+ * Plugin events
+ */
+export const PLUGIN_EVENTS = {
+    REGISTERED: 'plugin:registered',
+} as const;

package/src/core/app-kit/index.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.
+ *
+ */
+
+export { AppKit } from './services/app-kit';
+export { CONNECTOR_EVENTS, WALLETS_EVENTS, PLUGIN_EVENTS, NETWORKS_EVENTS } from './constants/events';
+
+export type { AppKitConfig } from './types/config';
+export type {
+    AppKitEmitter,
+    AppKitEvents,
+    WalletConnectedPayload,
+    WalletDisconnectedPayload,
+    PluginRegisteredPayload,
+} from './types/events';

package/src/core/app-kit/services/app-kit-network-manager.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 { ApiClient, Network } from '@ton/walletkit';
+import { KitNetworkManager } from '@ton/walletkit';
+
+import { NETWORKS_EVENTS } from '../constants/events';
+import type { AppKitEmitter } from '../types/events';
+
+export class AppKitNetworkManager extends KitNetworkManager {
+    private emitter: AppKitEmitter;
+
+    constructor(options: ConstructorParameters<typeof KitNetworkManager>[0], emitter: AppKitEmitter) {
+        super(options);
+        this.emitter = emitter;
+    }
+
+    override setClient(network: Network, client: ApiClient): void {
+        super.setClient(network, client);
+        this.emitter.emit(NETWORKS_EVENTS.UPDATED, {}, 'network-manager');
+    }
+}

package/src/core/app-kit/services/app-kit.ts

@@ -0,0 +1,123 @@
+/**
+ * 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 { NetworkManager } from '@ton/walletkit';
+import { Network, SwapManager } from '@ton/walletkit';
+import type { Provider } from 'src/types/provider';
+
+import type { AppKitConfig } from '../types/config';
+import type { Connector } from '../../../types/connector';
+import { Emitter } from '../../emitter';
+import { CONNECTOR_EVENTS, WALLETS_EVENTS } from '../constants/events';
+import type { AppKitEmitter, AppKitEvents } from '../types/events';
+import type { WalletInterface } from '../../../types/wallet';
+import { WalletsManager } from '../../wallets-manager';
+import { AppKitNetworkManager } from './app-kit-network-manager';
+
+/**
+ * Central hub for wallet management.
+ * Stores emitter, providers, and manages wallet connections.
+ */
+export class AppKit {
+    readonly emitter: AppKitEmitter;
+    readonly connectors: Connector[] = [];
+    readonly walletsManager: WalletsManager;
+    readonly swapManager: SwapManager;
+
+    readonly networkManager: NetworkManager;
+    readonly config: AppKitConfig;
+
+    constructor(config: AppKitConfig) {
+        this.config = config;
+
+        this.emitter = new Emitter<AppKitEvents>();
+        this.emitter.on(CONNECTOR_EVENTS.CONNECTED, this.updateWalletsFromConnectors.bind(this));
+        this.emitter.on(CONNECTOR_EVENTS.DISCONNECTED, this.updateWalletsFromConnectors.bind(this));
+
+        // Use provided networks config or default to mainnet
+        const networks = config.networks ?? {
+            [Network.mainnet().chainId]: {},
+        };
+
+        this.networkManager = new AppKitNetworkManager({ networks }, this.emitter);
+        this.walletsManager = new WalletsManager(this.emitter);
+        this.swapManager = new SwapManager();
+
+        if (config.connectors) {
+            config.connectors.forEach((connector) => {
+                this.addConnector(connector);
+            });
+        }
+
+        if (config.providers) {
+            config.providers.forEach((provider) => {
+                this.registerProvider(provider);
+            });
+        }
+    }
+
+    /**
+     * Add a wallet connector
+     */
+    addConnector(connector: Connector): () => void {
+        const id = connector.id;
+        const oldConnector = this.connectors.find((c) => c.id === id);
+
+        if (oldConnector) {
+            this.removeConnector(oldConnector);
+        }
+
+        this.connectors.push(connector);
+        connector.initialize(this.emitter, this.networkManager);
+
+        return () => {
+            this.removeConnector(connector);
+        };
+    }
+
+    /**
+     * Remove a wallet connector
+     */
+    removeConnector(connector: Connector): void {
+        const id = connector.id;
+        const oldConnector = this.connectors.find((c) => c.id === id);
+
+        if (oldConnector) {
+            oldConnector.destroy();
+            this.connectors.splice(this.connectors.indexOf(oldConnector), 1);
+        }
+    }
+
+    /**
+     * Add a provider
+     */
+    registerProvider(provider: Provider): void {
+        switch (provider.type) {
+            case 'swap':
+                this.swapManager.registerProvider(provider);
+                break;
+            default:
+                throw new Error('Unknown provider type');
+        }
+    }
+
+    /**
+     * Get all connected wallets from all connectors
+     */
+    private updateWalletsFromConnectors(): void {
+        const allWallets: WalletInterface[] = [];
+
+        for (const connector of this.connectors.values()) {
+            const wallets = connector.getConnectedWallets();
+            allWallets.push(...wallets);
+        }
+
+        this.walletsManager.setWallets(allWallets);
+        this.emitter.emit(WALLETS_EVENTS.UPDATED, { wallets: allWallets }, 'appkit');
+    }
+}

package/src/core/app-kit/types/config.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { NetworkAdapters } from '@ton/walletkit';
+
+import type { Connector } from '../../../types/connector';
+import type { Provider } from '../../../types/provider';
+
+/**
+ * Configuration for AppKit
+ */
+export interface AppKitConfig {
+    /**
+     * Network configuration
+     * At least one network must be configured.
+     *
+     * Keys are chain IDs (use `Network.mainnet().chainId` or `Network.testnet().chainId`)
+     * Values contain apiClient configuration (url and optional API key)
+     */
+    networks?: NetworkAdapters;
+    connectors?: Connector[];
+    providers?: Provider[];
+}

package/src/core/app-kit/types/events.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { Emitter } from '../../emitter';
+import type { CONNECTOR_EVENTS, WALLETS_EVENTS, PLUGIN_EVENTS, NETWORKS_EVENTS } from '../constants/events';
+import type { WalletInterface } from '../../../types/wallet';
+
+export interface WalletConnectedPayload {
+    wallets: WalletInterface[];
+    connectorId: string;
+}
+
+export interface WalletDisconnectedPayload {
+    connectorId: string;
+}
+
+export interface PluginRegisteredPayload {
+    pluginId: string;
+    pluginType: string;
+}
+
+export interface AppKitEvents {
+    // Connector events
+    [CONNECTOR_EVENTS.CONNECTED]: WalletConnectedPayload;
+    [CONNECTOR_EVENTS.DISCONNECTED]: WalletDisconnectedPayload;
+
+    // Wallets events
+    [WALLETS_EVENTS.UPDATED]: { wallets: WalletInterface[] };
+    [WALLETS_EVENTS.SELECTION_CHANGED]: { walletId: string | null };
+
+    // Networks events
+    [NETWORKS_EVENTS.UPDATED]: Record<string, never>;
+
+    // Plugin events
+    [PLUGIN_EVENTS.REGISTERED]: PluginRegisteredPayload;
+}
+
+export type AppKitEmitter = Emitter<AppKitEvents>;

package/src/core/emitter/index.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ *
+ */
+
+/**
+ * Events Feature
+ * Provides Emitter implementation
+ */
+export { Emitter } from './services/emitter';
+
+export type { EventPayload, AppKitEvent, EventListener } from './types/events';