@ton/appkit 0.0.5-alpha.3 → 1.0.0-alpha.1

package/src/actions/staking/get-staking-provider.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { StakingProviderInterface } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export type GetStakingProviderOptions = {
+    /**
+     * Provider ID to get. If not provided, returns default provider.
+     */
+    id?: string;
+};
+
+export type GetStakingProviderReturnType = StakingProviderInterface;
+
+/**
+ * Get staking provider instance
+ */
+export const getStakingProvider = (
+    appKit: AppKit,
+    options: GetStakingProviderOptions = {},
+): GetStakingProviderReturnType => {
+    return appKit.stakingManager.getProvider(options.id);
+};

package/src/actions/staking/get-staking-providers.ts

@@ -6,13 +6,15 @@
  *
  */
 
+import type { StakingProviderInterface } from '@ton/walletkit';
+
 import type { AppKit } from '../../core/app-kit';
 
-export type GetStakingProvidersReturnType = string[];
+export type GetStakingProvidersReturnType = StakingProviderInterface[];
 
 /**
- * Get available staking provider IDs
+ * Get all registered staking providers.
  */
 export const getStakingProviders = (appKit: AppKit): GetStakingProvidersReturnType => {
-    return appKit.stakingManager.getRegisteredProviders();
+    return appKit.stakingManager.getProviders();
 };

package/src/actions/staking/set-default-staking-provider.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 SetDefaultStakingProviderParameters {
+    providerId: string;
+}
+
+export type SetDefaultStakingProviderReturnType = void;
+
+/**
+ * Set the default staking provider.
+ * Subsequent quote and stake-transaction calls will use this provider when none is specified.
+ */
+export const setDefaultStakingProvider = (
+    appKit: AppKit,
+    parameters: SetDefaultStakingProviderParameters,
+): SetDefaultStakingProviderReturnType => {
+    appKit.stakingManager.setDefaultProvider(parameters.providerId);
+};

package/src/actions/staking/watch-staking-providers.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 WatchStakingProvidersParameters {
+    onChange: () => void;
+}
+
+export type WatchStakingProvidersReturnType = () => void;
+
+/**
+ * Watch for staking providers registration and default provider changes
+ */
+export const watchStakingProviders = (
+    appKit: AppKit,
+    parameters: WatchStakingProvidersParameters,
+): WatchStakingProvidersReturnType => {
+    const { onChange } = parameters;
+
+    const onEvent = (event: { payload: { type: string } }) => {
+        if (event.payload.type === 'staking') {
+            onChange();
+        }
+    };
+
+    const unsubscribeRegistered = appKit.emitter.on('provider:registered', onEvent);
+    const unsubscribeDefaultChanged = appKit.emitter.on('provider:default-changed', onEvent);
+
+    return () => {
+        unsubscribeRegistered();
+        unsubscribeDefaultChanged();
+    };
+};

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

@@ -0,0 +1,21 @@
+/**
+ * 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 { SwapProviderInterface } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetSwapProviderOptions {
+    id?: string;
+}
+
+export type GetSwapProviderReturnType = SwapProviderInterface;
+
+export const getSwapProvider = (appKit: AppKit, options: GetSwapProviderOptions = {}): GetSwapProviderReturnType => {
+    return appKit.swapManager.getProvider(options.id);
+};

package/src/actions/swap/get-swap-providers.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 { SwapProviderInterface } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export type GetSwapProvidersReturnType = SwapProviderInterface[];
+
+/**
+ * Get all registered swap providers.
+ */
+export const getSwapProviders = (appKit: AppKit): GetSwapProvidersReturnType => {
+    return appKit.swapManager.getProviders();
+};

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

@@ -9,6 +9,7 @@
 import type { SwapQuote, SwapQuoteParams } from '@ton/walletkit';
 
 import type { AppKit } from '../../core/app-kit';
+import { resolveNetwork } from '../../utils';
 
 export type GetSwapQuoteOptions<T = unknown> = SwapQuoteParams<T> & {
     providerId?: string;
@@ -23,5 +24,10 @@ export const getSwapQuote = async <T = unknown>(
     appKit: AppKit,
     options: GetSwapQuoteOptions<T>,
 ): GetSwapQuoteReturnType => {
-    return appKit.swapManager.getQuote(options, options.providerId);
+    const optionsWithNetwork = {
+        ...options,
+        network: resolveNetwork(appKit, options.network),
+    };
+
+    return appKit.swapManager.getQuote(optionsWithNetwork, options.providerId);
 };

package/src/actions/swap/set-default-swap-provider.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 SetDefaultSwapProviderParameters {
+    providerId: string;
+}
+
+export type SetDefaultSwapProviderReturnType = void;
+
+/**
+ * Set the default swap provider.
+ * Subsequent quote and swap-transaction calls will use this provider when none is specified.
+ */
+export const setDefaultSwapProvider = (
+    appKit: AppKit,
+    parameters: SetDefaultSwapProviderParameters,
+): SetDefaultSwapProviderReturnType => {
+    appKit.swapManager.setDefaultProvider(parameters.providerId);
+};

package/src/actions/swap/watch-swap-providers.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 WatchSwapProvidersParameters {
+    onChange: () => void;
+}
+
+export type WatchSwapProvidersReturnType = () => void;
+
+/**
+ * Watch for new swap providers registration
+ */
+export const watchSwapProviders = (
+    appKit: AppKit,
+    parameters: WatchSwapProvidersParameters,
+): WatchSwapProvidersReturnType => {
+    const { onChange } = parameters;
+
+    const unsubscribeRegistered = appKit.emitter.on('provider:registered', (event) => {
+        if (event.payload.type === 'swap') onChange();
+    });
+
+    const unsubscribeDefaultChanged = appKit.emitter.on('provider:default-changed', (event) => {
+        if (event.payload.type === 'swap') onChange();
+    });
+
+    return () => {
+        unsubscribeRegistered();
+        unsubscribeDefaultChanged();
+    };
+};

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

@@ -11,14 +11,13 @@ import type { TonConnectUiCreateOptions } from '@tonconnect/ui';
 
 import { TonConnectWalletAdapter } from '../adapters/ton-connect-wallet-adapter';
 import { CONNECTOR_EVENTS, NETWORKS_EVENTS } from '../../../core/app-kit';
-import type { Connector, ConnectorMetadata } from '../../../types/connector';
+import type { Connector } from '../../../types/connector';
 import type { WalletInterface } from '../../../types/wallet';
 import { TONCONNECT_DEFAULT_CONNECTOR_ID } from '../constants/id';
 import { createConnector } from '../../../types/connector';
 
 export interface TonConnectConnectorConfig {
     id?: string;
-    metadata?: ConnectorMetadata;
     tonConnectOptions?: TonConnectUiCreateOptions;
     tonConnectUI?: TonConnectUI;
 }
@@ -29,18 +28,24 @@ export type TonConnectConnector = Connector & {
 };
 
 export const createTonConnectConnector = (config: TonConnectConnectorConfig) => {
-    return createConnector(({ eventEmitter, networkManager, ssr }): TonConnectConnector => {
+    return createConnector(({ eventEmitter, networkManager }): TonConnectConnector => {
         let originalTonConnectUI: TonConnectUI | null = null;
         let unsubscribeTonConnect: (() => void) | null = null;
+        let unsubscribeDefaultNetwork: (() => void) | null = null;
+        let destroyed = false;
 
         const id = config.id ?? TONCONNECT_DEFAULT_CONNECTOR_ID;
 
-        function getTonConnectUI() {
+        const getTonConnectUI = (): TonConnectUI | null => {
+            if (destroyed) {
+                return null;
+            }
+
             if (originalTonConnectUI) {
                 return originalTonConnectUI;
             }
 
-            if (ssr && typeof window === 'undefined') {
+            if (typeof window === 'undefined') {
                 return null;
             }
 
@@ -59,7 +64,7 @@ export const createTonConnectConnector = (config: TonConnectConnectorConfig) =>
             }
 
             return originalTonConnectUI;
-        }
+        };
 
         function getConnectedWallets(): WalletInterface[] {
             const ui = getTonConnectUI();
@@ -84,19 +89,17 @@ export const createTonConnectConnector = (config: TonConnectConnectorConfig) =>
                 return;
             }
 
-            unsubscribeTonConnect = originalTonConnectUI.onStatusChange((wallet) => {
-                const wallets = getConnectedWallets();
-
-                if (wallet) {
-                    eventEmitter.emit(CONNECTOR_EVENTS.CONNECTED, { wallets, connectorId: id }, id);
-                } else {
-                    eventEmitter.emit(CONNECTOR_EVENTS.DISCONNECTED, { connectorId: id }, id);
-                }
+            unsubscribeTonConnect = originalTonConnectUI.onStatusChange(() => {
+                eventEmitter.emit(
+                    CONNECTOR_EVENTS.WALLETS_UPDATED,
+                    { connectorId: id, wallets: getConnectedWallets() },
+                    id,
+                );
             });
 
             // Set default network and subscribe to changes
             originalTonConnectUI.setConnectionNetwork(networkManager.getDefaultNetwork()?.chainId);
-            eventEmitter.on(NETWORKS_EVENTS.DEFAULT_CHANGED, ({ payload }) => {
+            unsubscribeDefaultNetwork = eventEmitter.on(NETWORKS_EVENTS.DEFAULT_CHANGED, ({ payload }) => {
                 if (originalTonConnectUI) {
                     originalTonConnectUI.setConnectionNetwork(payload.network?.chainId);
                 }
@@ -106,11 +109,6 @@ export const createTonConnectConnector = (config: TonConnectConnectorConfig) =>
         return {
             id,
             type: 'tonconnect',
-            metadata: {
-                name: 'TonConnect',
-                iconUrl: 'https://avatars.githubusercontent.com/u/113980577',
-                ...config.metadata,
-            },
 
             get tonConnectUI() {
                 return getTonConnectUI();
@@ -135,7 +133,11 @@ export const createTonConnectConnector = (config: TonConnectConnectorConfig) =>
             },
 
             destroy() {
+                destroyed = true;
                 unsubscribeTonConnect?.();
+                unsubscribeDefaultNetwork?.();
+                unsubscribeTonConnect = null;
+                unsubscribeDefaultNetwork = null;
                 originalTonConnectUI = null;
             },
         };

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

@@ -10,8 +10,9 @@
  * Connector events
  */
 export const CONNECTOR_EVENTS = {
-    CONNECTED: 'connector:connected',
-    DISCONNECTED: 'connector:disconnected',
+    ADDED: 'connector:added',
+    REMOVED: 'connector:removed',
+    WALLETS_UPDATED: 'connector:wallets-updated',
 } as const;
 
 /**
@@ -29,10 +30,3 @@ export const NETWORKS_EVENTS = {
     UPDATED: 'networks:updated',
     DEFAULT_CHANGED: 'networks:default-changed',
 } as const;
-
-/**
- * Plugin events
- */
-export const PLUGIN_EVENTS = {
-    REGISTERED: 'plugin:registered',
-} as const;

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

@@ -7,14 +7,14 @@
  */
 
 export { AppKit } from './services/app-kit';
-export { CONNECTOR_EVENTS, WALLETS_EVENTS, PLUGIN_EVENTS, NETWORKS_EVENTS } from './constants/events';
+export { CONNECTOR_EVENTS, WALLETS_EVENTS, NETWORKS_EVENTS } from './constants/events';
 
 export type { AppKitConfig } from './types/config';
 export type {
     AppKitEmitter,
     AppKitEvents,
-    WalletConnectedPayload,
-    WalletDisconnectedPayload,
-    PluginRegisteredPayload,
+    ConnectorAddedPayload,
+    ConnectorRemovedPayload,
+    ConnectorWalletsUpdatedPayload,
     DefaultNetworkChangedPayload,
 } from './types/events';

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

@@ -7,18 +7,21 @@
  */
 
 import { SwapManager, StreamingManager } from '@ton/walletkit';
-import type { ProviderInput, SwapProviderInterface, StakingProviderInterface } from '@ton/walletkit';
+import type { ProviderInput, SwapProviderInterface, StakingProviderInterface, StreamingProvider } from '@ton/walletkit';
 
+import type { AppKitConfig } from '../types/config';
+import { CONNECTOR_EVENTS, WALLETS_EVENTS } from '../constants/events';
 import { StakingManager } from '../../../staking';
 import type { Connector, ConnectorFactoryContext, ConnectorInput } from '../../../types/connector';
 import { EventEmitter } 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 '../../network';
 import { Network } from '../../../types/network';
-import type { AppKitConfig } from '../types/config';
+import type { AppKitCache } from '../../cache';
+import { LruAppKitCache } from '../../cache';
+import type { AppKitProvider } from '../../../types/provider';
 
 /**
  * Central hub for wallet management.
@@ -34,13 +37,14 @@ export class AppKit {
     readonly networkManager: AppKitNetworkManager;
     readonly streamingManager: StreamingManager;
     readonly config: AppKitConfig;
+    readonly cache: AppKitCache;
 
     constructor(config: AppKitConfig) {
         this.config = config;
+        this.cache = config.cache ?? new LruAppKitCache();
 
         this.emitter = new EventEmitter<AppKitEvents>();
-        this.emitter.on(CONNECTOR_EVENTS.CONNECTED, this.updateWalletsFromConnectors.bind(this));
-        this.emitter.on(CONNECTOR_EVENTS.DISCONNECTED, this.updateWalletsFromConnectors.bind(this));
+        this.emitter.on(CONNECTOR_EVENTS.WALLETS_UPDATED, this.updateWalletsFromConnectors.bind(this));
 
         // Use provided networks config or default to mainnet
         const networks = config.networks ?? {
@@ -68,7 +72,7 @@ export class AppKit {
     }
 
     createFactoryContext(): ConnectorFactoryContext {
-        return { eventEmitter: this.emitter, networkManager: this.networkManager, ssr: this.config?.ssr };
+        return { eventEmitter: this.emitter, networkManager: this.networkManager };
     }
 
     /**
@@ -84,6 +88,8 @@ export class AppKit {
         }
 
         this.connectors.push(connector);
+        this.updateWalletsFromConnectors();
+        this.emitter.emit(CONNECTOR_EVENTS.ADDED, { connector }, 'appkit');
 
         return () => {
             this.removeConnector(connector);
@@ -100,13 +106,15 @@ export class AppKit {
         if (oldConnector) {
             oldConnector.destroy();
             this.connectors.splice(this.connectors.indexOf(oldConnector), 1);
+            this.updateWalletsFromConnectors();
+            this.emitter.emit(CONNECTOR_EVENTS.REMOVED, { connector: oldConnector }, 'appkit');
         }
     }
 
     /**
      * Add a provider
      */
-    registerProvider(input: ProviderInput): void {
+    registerProvider(input: ProviderInput<AppKitProvider>): void {
         const provider = typeof input === 'function' ? input(this.createFactoryContext()) : input;
         switch (provider.type) {
             case 'swap':
@@ -115,6 +123,9 @@ export class AppKit {
             case 'staking':
                 this.stakingManager.registerProvider(provider as StakingProviderInterface);
                 break;
+            case 'streaming':
+                this.streamingManager.registerProvider(provider as StreamingProvider);
+                break;
             default:
                 throw new Error('Unknown provider type');
         }

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

@@ -8,8 +8,10 @@
 
 import type { NetworkAdapters, ProviderInput } from '@ton/walletkit';
 
+import type { AppKitCache } from '../../cache';
 import type { ConnectorInput } from '../../../types/connector';
 import type { Network } from '../../../types/network';
+import type { AppKitProvider } from '../../../types/provider';
 
 /**
  * Configuration for AppKit
@@ -36,10 +38,11 @@ export interface AppKitConfig {
      */
     defaultNetwork?: Network;
 
-    providers?: ProviderInput[];
+    providers?: ProviderInput<AppKitProvider>[];
 
     /**
-     * Enable server-side rendering support
+     * Custom cache implementation.
+     * Defaults to an LRU cache with a 10-minute TTL and a maximum of 1000 entries.
      */
-    ssr?: boolean;
+    cache?: AppKitCache;
 }

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

@@ -6,24 +6,24 @@
  *
  */
 
-import type { SharedKitEvents } from '../../emitter';
-import type { CONNECTOR_EVENTS, WALLETS_EVENTS, PLUGIN_EVENTS, NETWORKS_EVENTS } from '../constants/events';
+import type { Connector } from '../../../types/connector';
 import type { Network } from '../../../types/network';
+import type { CONNECTOR_EVENTS, WALLETS_EVENTS, NETWORKS_EVENTS } from '../constants/events';
+import type { SharedKitEvents } from '../../emitter';
 import type { EventEmitter } from '../../emitter';
 import type { WalletInterface } from '../../../types/wallet';
 
-export interface WalletConnectedPayload {
-    wallets: WalletInterface[];
-    connectorId: string;
+export interface ConnectorAddedPayload {
+    connector: Connector;
 }
 
-export interface WalletDisconnectedPayload {
-    connectorId: string;
+export interface ConnectorRemovedPayload {
+    connector: Connector;
 }
 
-export interface PluginRegisteredPayload {
-    pluginId: string;
-    pluginType: string;
+export interface ConnectorWalletsUpdatedPayload {
+    connectorId: string;
+    wallets: WalletInterface[];
 }
 
 export interface DefaultNetworkChangedPayload {
@@ -32,8 +32,9 @@ export interface DefaultNetworkChangedPayload {
 
 export type AppKitEvents = {
     // Connector events
-    [CONNECTOR_EVENTS.CONNECTED]: WalletConnectedPayload;
-    [CONNECTOR_EVENTS.DISCONNECTED]: WalletDisconnectedPayload;
+    [CONNECTOR_EVENTS.ADDED]: ConnectorAddedPayload;
+    [CONNECTOR_EVENTS.REMOVED]: ConnectorRemovedPayload;
+    [CONNECTOR_EVENTS.WALLETS_UPDATED]: ConnectorWalletsUpdatedPayload;
 
     // Wallets events
     [WALLETS_EVENTS.UPDATED]: { wallets: WalletInterface[] };
@@ -42,9 +43,6 @@ export type AppKitEvents = {
     // Networks events
     [NETWORKS_EVENTS.UPDATED]: Record<string, never>;
     [NETWORKS_EVENTS.DEFAULT_CHANGED]: DefaultNetworkChangedPayload;
-
-    // Plugin events
-    [PLUGIN_EVENTS.REGISTERED]: PluginRegisteredPayload;
 } & SharedKitEvents;
 
 export type AppKitEmitter = EventEmitter<AppKitEvents>;

package/src/core/cache/adapters/lru-app-kit-cache.test.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+
+import { LruAppKitCache } from './lru-app-kit-cache';
+
+describe('LruAppKitCache', () => {
+    it('should return undefined for a missing key', async () => {
+        const cache = new LruAppKitCache();
+        expect(await cache.get('missing')).toBeUndefined();
+    });
+
+    it('should store and retrieve a value', async () => {
+        const cache = new LruAppKitCache();
+        await cache.set('key', 'value');
+        expect(await cache.get('key')).toBe('value');
+    });
+
+    it('should store and retrieve null', async () => {
+        const cache = new LruAppKitCache();
+        await cache.set('key', null);
+        expect(await cache.get('key')).toBeNull();
+    });
+
+    it('should store and retrieve an object', async () => {
+        const cache = new LruAppKitCache();
+        const obj = { address: 'EQabc', name: 'Test', decimals: 6 };
+        await cache.set('key', obj);
+        expect(await cache.get('key')).toEqual(obj);
+    });
+
+    it('should overwrite an existing value', async () => {
+        const cache = new LruAppKitCache();
+        await cache.set('key', 'first');
+        await cache.set('key', 'second');
+        expect(await cache.get('key')).toBe('second');
+    });
+
+    it('should remove a key', async () => {
+        const cache = new LruAppKitCache();
+        await cache.set('key', 'value');
+        await cache.remove('key');
+        expect(await cache.get('key')).toBeUndefined();
+    });
+
+    it('should clear all keys', async () => {
+        const cache = new LruAppKitCache();
+        await cache.set('a', 1);
+        await cache.set('b', 2);
+        await cache.clear();
+        expect(await cache.get('a')).toBeUndefined();
+        expect(await cache.get('b')).toBeUndefined();
+    });
+
+    it('should evict entries when max is exceeded', async () => {
+        const cache = new LruAppKitCache({ max: 2 });
+        await cache.set('a', 1);
+        await cache.set('b', 2);
+        await cache.set('c', 3);
+        expect(await cache.get('a')).toBeUndefined();
+        expect(await cache.get('b')).toBe(2);
+        expect(await cache.get('c')).toBe(3);
+    });
+
+    it('should expire entries after ttl', async () => {
+        const cache = new LruAppKitCache({ ttl: 10 });
+        await cache.set('key', 'value');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        expect(await cache.get('key')).toBeUndefined();
+    });
+});