TON 636: Staking android

packages/walletkit-android-bridge/src/api/index.ts

@@ -18,6 +18,7 @@ import * as requests from './requests';
 import * as tonconnect from './tonconnect';
 import * as nft from './nft';
 import * as jettons from './jettons';
+import * as staking from './staking';
 import * as browser from './browser';
 import * as swap from './swap';
 import { eventListeners } from './eventListeners';
@@ -92,6 +93,16 @@ export const api: WalletKitBridgeApi = {
     emitBrowserError: browser.emitBrowserError,
     emitBrowserBridgeRequest: browser.emitBrowserBridgeRequest,
 
+    // Staking
+    createTonStakersStakingProvider: staking.createTonStakersStakingProvider,
+    registerStakingProvider: staking.registerStakingProvider,
+    setDefaultStakingProvider: staking.setDefaultStakingProvider,
+    getStakingQuote: staking.getStakingQuote,
+    buildStakeTransaction: staking.buildStakeTransaction,
+    getStakedBalance: staking.getStakedBalance,
+    getStakingProviderInfo: staking.getStakingProviderInfo,
+    getSupportedUnstakeModes: staking.getSupportedUnstakeModes,
+
     // Swap
     createOmnistonSwapProvider: swap.createOmnistonSwapProvider,
     createDeDustSwapProvider: swap.createDeDustSwapProvider,

packages/walletkit-android-bridge/src/api/staking.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 { StakingProviderInterface, StakingQuoteParams, StakeParams } from '@ton/walletkit';
+import { TonStakersStakingProvider } from '@ton/walletkit/staking/tonstakers';
+import type { TonStakersProviderConfig } from '@ton/walletkit/staking/tonstakers';
+
+import { getKit } from '../utils/bridge';
+import { retain, get } from '../utils/registry';
+
+export async function createTonStakersStakingProvider(args?: { config?: TonStakersProviderConfig }) {
+    const instance = await getKit();
+    const provider = TonStakersStakingProvider.createFromContext(instance.createFactoryContext(), args?.config ?? {});
+    const providerId = retain('stakingProvider', provider);
+    return { providerId };
+}
+
+export async function registerStakingProvider(args: { providerId: string }) {
+    const provider = get<StakingProviderInterface>(args.providerId);
+    if (!provider) throw new Error(`Staking provider not found: ${args.providerId}`);
+    const instance = await getKit();
+    instance.staking.registerProvider(provider);
+}
+
+export async function setDefaultStakingProvider(args: { providerId: string }) {
+    const instance = await getKit();
+    instance.staking.setDefaultProvider(args.providerId);
+}
+
+export async function getStakingQuote(args: StakingQuoteParams & { providerId?: string }) {
+    const { providerId, ...params } = args;
+    const instance = await getKit();
+    return instance.staking.getQuote(params, providerId);
+}
+
+export async function buildStakeTransaction(args: StakeParams & { providerId?: string }) {
+    const { providerId, ...params } = args;
+    const instance = await getKit();
+    return instance.staking.buildStakeTransaction(params, providerId);
+}
+
+export async function getStakedBalance(args: {
+    userAddress: string;
+    network?: { chainId: string };
+    providerId?: string;
+}) {
+    const instance = await getKit();
+    return instance.staking.getStakedBalance(args.userAddress, args.network, args.providerId);
+}
+
+export async function getStakingProviderInfo(args: { network?: { chainId: string }; providerId?: string }) {
+    const instance = await getKit();
+    return instance.staking.getStakingProviderInfo(args.network, args.providerId);
+}
+
+export async function getSupportedUnstakeModes(args: { providerId?: string }) {
+    const instance = await getKit();
+    return instance.staking.getSupportedUnstakeModes(args.providerId);
+}

packages/walletkit-android-bridge/src/api/transactions.ts

@@ -8,18 +8,20 @@
 
 import type { TransactionRequest } from '@ton/walletkit';
 
-import { walletCall, clientCall, getKit, getWallet } from '../utils/bridge';
+import { wallet, walletCall, clientCall, getKit, getWallet } from '../utils/bridge';
 
 export const createTransferTonTransaction = (args: { walletId: string }) =>
     walletCall('createTransferTonTransaction', args);
 export const createTransferMultiTonTransaction = (args: { walletId: string }) =>
     walletCall('createTransferMultiTonTransaction', args);
-export const getTransactionPreview = (args: { walletId: string }) => walletCall('getTransactionPreview', args);
-export const sendTransaction = (args: { walletId: string }) => walletCall('sendTransaction', args);
+export const getTransactionPreview = (args: { walletId: string; transactionContent: TransactionRequest }) =>
+    wallet(args.walletId, 'getTransactionPreview', args.transactionContent);
+export const sendTransaction = (args: { walletId: string; transactionContent: TransactionRequest }) =>
+    wallet(args.walletId, 'sendTransaction', args.transactionContent);
 export const getRecentTransactions = (args: { walletId: string }) => clientCall('getAccountTransactions', args);
 
-export async function handleNewTransaction(args: [string, unknown]) {
+export async function handleNewTransaction(args: { walletId: string; transactionContent: TransactionRequest }) {
     const k = await getKit();
-    const w = await getWallet(args[0]);
-    return k.handleNewTransaction(w, args[1] as TransactionRequest);
+    const w = await getWallet(args.walletId);
+    return k.handleNewTransaction(w, args.transactionContent);
 }

packages/walletkit-android-bridge/src/types/api.ts

@@ -121,7 +121,7 @@ export interface CreateTransferMultiTonTransactionArgs {
 
 export interface TransactionContentArgs {
     walletId: string;
-    transactionContent: TransactionRequest | string; // Can be object (from Kotlin) or string (legacy)
+    transactionContent: TransactionRequest;
 }
 
 export interface TonConnectRequestEvent extends BridgeEvent {
@@ -263,6 +263,71 @@ export interface HandleTonConnectUrlArgs {
     url: string;
 }
 
+export interface TonStakersChainConfig {
+    contractAddress?: string;
+    tonApiToken?: string;
+}
+
+export interface CreateTonStakersStakingProviderArgs {
+    config?: {
+        mainnet?: TonStakersChainConfig;
+        testnet?: TonStakersChainConfig;
+    };
+}
+
+export interface RegisterStakingProviderArgs {
+    providerId: string;
+}
+
+export interface SetDefaultStakingProviderArgs {
+    providerId: string;
+}
+
+export interface GetStakingQuoteArgs {
+    direction: 'stake' | 'unstake';
+    amount: string;
+    userAddress?: string;
+    network?: { chainId: string };
+    unstakeMode?: string;
+    providerOptions?: unknown;
+    providerId?: string;
+}
+
+export interface BuildStakeTransactionArgs {
+    quote: StakingQuoteResponse;
+    userAddress: string;
+    providerOptions?: unknown;
+    providerId?: string;
+}
+
+export interface StakingQuoteResponse {
+    direction: 'stake' | 'unstake';
+    amountIn: string;
+    amountOut: string;
+    network: { chainId: string };
+    providerId: string;
+    apy?: number;
+    unstakeMode?: string;
+    estimatedUnstakeDelayHours?: number;
+    instantUnstakeAvailable?: string;
+    metadata?: unknown;
+}
+
+export interface GetStakedBalanceArgs {
+    userAddress: string;
+    network?: { chainId: string };
+    providerId?: string;
+}
+
+export interface GetStakingProviderInfoArgs {
+    network?: { chainId: string };
+    providerId?: string;
+}
+
+export interface GetSupportedUnstakeModesArgs {
+    providerId?: string;
+}
+
 export interface CreateOmnistonSwapProviderArgs {
     config?: Record<string, unknown>;
 }
@@ -321,7 +386,7 @@ export interface WalletKitBridgeApi {
     createTransferTonTransaction(args: CreateTransferTonTransactionArgs): PromiseOrValue<TransactionRequest>;
     createTransferMultiTonTransaction(args: CreateTransferMultiTonTransactionArgs): PromiseOrValue<TransactionRequest>;
     getTransactionPreview(args: TransactionContentArgs): PromiseOrValue<TransactionEmulatedPreview>;
-    handleNewTransaction(args: TransactionContentArgs): PromiseOrValue<{ success: boolean }>;
+    handleNewTransaction(args: TransactionContentArgs): PromiseOrValue<void>;
     sendTransaction(args: TransactionContentArgs): PromiseOrValue<SendTransactionResponse>;
     approveConnectRequest(args: ApproveConnectRequestArgs): PromiseOrValue<void>;
     rejectConnectRequest(args: RejectConnectRequestArgs): PromiseOrValue<{ success: boolean }>;
@@ -344,6 +409,22 @@ export interface WalletKitBridgeApi {
     emitBrowserPageFinished(args: EmitBrowserPageArgs): PromiseOrValue<{ success: boolean }>;
     emitBrowserError(args: EmitBrowserErrorArgs): PromiseOrValue<{ success: boolean }>;
     emitBrowserBridgeRequest(args: EmitBrowserBridgeRequestArgs): PromiseOrValue<{ success: boolean }>;
+    createTonStakersStakingProvider(args?: CreateTonStakersStakingProviderArgs): PromiseOrValue<{ providerId: string }>;
+    registerStakingProvider(args: RegisterStakingProviderArgs): PromiseOrValue<void>;
+    setDefaultStakingProvider(args: SetDefaultStakingProviderArgs): PromiseOrValue<void>;
+    getStakingQuote(args: GetStakingQuoteArgs): PromiseOrValue<StakingQuoteResponse>;
+    buildStakeTransaction(args: BuildStakeTransactionArgs): PromiseOrValue<unknown>;
+    getStakedBalance(args: GetStakedBalanceArgs): PromiseOrValue<{
+        stakedBalance: string;
+        instantUnstakeAvailable: string;
+        providerId: string;
+    }>;
+    getStakingProviderInfo(args: GetStakingProviderInfoArgs): PromiseOrValue<{
+        apy: number;
+        instantUnstakeAvailable?: string;
+        providerId: string;
+    }>;
+    getSupportedUnstakeModes(args: GetSupportedUnstakeModesArgs): PromiseOrValue<string[]>;
 
     // Swap
     createOmnistonSwapProvider(args: CreateOmnistonSwapProviderArgs): PromiseOrValue<{ providerId: string }>;

packages/walletkit-android-bridge/src/types/walletkit.ts

@@ -6,29 +6,7 @@
  *
  */
 
-import type {
-    ApiClient,
-    BridgeEventMessageInfo,
-    ConnectionApprovalResponse,
-    ConnectionRequestEvent,
-    DeviceInfo,
-    DisconnectionEvent,
-    InjectedToExtensionBridgeRequestPayload,
-    Network,
-    RequestErrorEvent,
-    SendTransactionApprovalResponse,
-    SendTransactionRequestEvent,
-    SignDataApprovalResponse,
-    SignDataRequestEvent,
-    SwapAPI,
-    TONConnectSession,
-    TransactionRequest,
-    Wallet,
-    WalletAdapter,
-    WalletInfo,
-    WalletSigner,
-} from '@ton/walletkit';
-import type { CONNECT_EVENT_ERROR_CODES, SendTransactionRpcResponseError } from '@tonconnect/protocol';
+import type { DeviceInfo, TonWalletKit, WalletAdapter, WalletInfo, WalletSigner } from '@ton/walletkit';
 
 /**
  * Configuration and bridge-facing types for Ton WalletKit.
@@ -66,56 +44,4 @@ export interface WalletKitNativeBridgeType {
 
 export type WalletKitAdapter = WalletAdapter;
 export type WalletKitSigner = WalletSigner;
-
-export interface WalletKitInstance {
-    ensureInitialized?: () => Promise<void>;
-    getWallets: () => Wallet[];
-    getWallet(walletId: string): Wallet | undefined;
-    getNetwork?: () => string;
-    removeWallet(walletId: string): Promise<void>;
-    getApiClient(network?: Network): ApiClient;
-    addWallet(adapter: WalletAdapter): Promise<Wallet | null>;
-    handleNewTransaction(wallet: Wallet, transaction: TransactionRequest): Promise<void>;
-    handleTonConnectUrl(url: string): Promise<void>;
-    connectionEventFromUrl?(url: string): Promise<ConnectionRequestEvent>;
-    listSessions?(): Promise<TONConnectSession[]>;
-    disconnect?(sessionId?: string): Promise<void>;
-    processInjectedBridgeRequest?(
-        messageInfo: BridgeEventMessageInfo,
-        request: InjectedToExtensionBridgeRequestPayload,
-    ): Promise<void>;
-    onConnectRequest(callback: (event: ConnectionRequestEvent) => void): void;
-    removeConnectRequestCallback(): void;
-    onTransactionRequest(callback: (event: SendTransactionRequestEvent) => void): void;
-    removeTransactionRequestCallback(): void;
-    onSignDataRequest(callback: (event: SignDataRequestEvent) => void): void;
-    removeSignDataRequestCallback(): void;
-    onDisconnect(callback: (event: DisconnectionEvent) => void): void;
-    removeDisconnectCallback(): void;
-    onRequestError(callback: (event: RequestErrorEvent) => void): void;
-    removeErrorCallback(): void;
-    // Request approval methods - event and response are separate parameters
-    approveConnectRequest(event: ConnectionRequestEvent, response?: ConnectionApprovalResponse): Promise<void>;
-    rejectConnectRequest(
-        event: ConnectionRequestEvent,
-        reason?: string,
-        errorCode?: CONNECT_EVENT_ERROR_CODES,
-    ): Promise<void>;
-    approveTransactionRequest(
-        event: SendTransactionRequestEvent,
-        response?: SendTransactionApprovalResponse,
-    ): Promise<SendTransactionApprovalResponse>;
-    rejectTransactionRequest(
-        event: SendTransactionRequestEvent,
-        reason?: string | SendTransactionRpcResponseError['error'],
-    ): Promise<void>;
-    approveSignDataRequest(
-        event: SignDataRequestEvent,
-        response?: SignDataApprovalResponse,
-    ): Promise<SignDataApprovalResponse>;
-    rejectSignDataRequest(
-        event: SignDataRequestEvent,
-        reason?: string | SendTransactionRpcResponseError['error'],
-    ): Promise<void>;
-    swap?: SwapAPI;
-}
+export type WalletKitInstance = TonWalletKit;