Feature/ton 1663 gasless android

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

@@ -0,0 +1,80 @@
+/**
+ * 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 {
+    GaslessAPI,
+    GaslessConfig,
+    GaslessProviderInterface,
+    GaslessProviderMetadata,
+    GaslessQuote,
+    GaslessQuoteParams,
+    GaslessSendParams,
+    GaslessSendResponse,
+    Network,
+} from '@ton/walletkit';
+import { TonApiGaslessProvider } from '@ton/walletkit/gasless/tonapi';
+import type { TonApiGaslessProviderConfig } from '@ton/walletkit/gasless/tonapi';
+
+import { getKit } from '../utils/bridge';
+import { get, retainWithId } from '../utils/registry';
+
+async function getGasless(): Promise<GaslessAPI> {
+    const instance = await getKit();
+    if (!instance.gasless) throw new Error('Gasless is not configured');
+    return instance.gasless;
+}
+
+export async function createTonApiGaslessProvider(args?: {
+    config?: TonApiGaslessProviderConfig;
+}): Promise<{ providerId: string }> {
+    const instance = await getKit();
+    const provider = TonApiGaslessProvider.createFromContext(instance.createFactoryContext(), args?.config ?? {});
+    // Retain under the provider's own id so it matches what GaslessManager indexes on registerProvider.
+    retainWithId(provider.providerId, provider);
+    return { providerId: provider.providerId };
+}
+
+export async function registerGaslessProvider(args: { providerId: string }): Promise<void> {
+    (await getGasless()).registerProvider(get(args.providerId) as GaslessProviderInterface);
+}
+
+export async function setDefaultGaslessProvider(args: { providerId: string }): Promise<void> {
+    (await getGasless()).setDefaultProvider(args.providerId);
+}
+
+export async function getRegisteredGaslessProviders(): Promise<{ providerIds: string[] }> {
+    const providerIds = (await getGasless()).getProviders().map((provider) => provider.providerId);
+    return { providerIds };
+}
+
+export async function hasGaslessProvider(args: { providerId: string }): Promise<{ result: boolean }> {
+    const result = (await getGasless()).hasProvider(args.providerId);
+    return { result };
+}
+
+export async function getGaslessMetadata(args: { providerId?: string }): Promise<GaslessProviderMetadata> {
+    return (await getGasless()).getMetadata(args.providerId);
+}
+
+export async function getGaslessConfig(args: { network?: Network; providerId?: string }): Promise<GaslessConfig> {
+    return (await getGasless()).getConfig(args.network, args.providerId);
+}
+
+export async function getGaslessQuote(args: {
+    params: GaslessQuoteParams;
+    providerId?: string;
+}): Promise<GaslessQuote> {
+    return (await getGasless()).getQuote(args.params, args.providerId);
+}
+
+export async function gaslessSendTransaction(args: {
+    params: GaslessSendParams;
+    providerId?: string;
+}): Promise<GaslessSendResponse> {
+    return (await getGasless()).sendTransaction(args.params, args.providerId);
+}

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

@@ -19,6 +19,7 @@ import * as staking from './staking';
 import * as browser from './browser';
 import * as streaming from './streaming';
 import * as swap from './swap';
+import * as gasless from './gasless';
 import * as walletClient from './walletClient';
 import { eventListeners } from './eventListeners';
 
@@ -45,6 +46,8 @@ export const api = {
     getWallet: wallets.getWalletById,
     getWalletAddress: wallets.getWalletAddress,
     getWalletNetwork: wallets.getWalletNetwork,
+    getWalletPublicKey: wallets.getWalletPublicKey,
+    getSignedSignMessage: wallets.getSignedSignMessage,
     removeWallet: wallets.removeWallet,
     getBalance: wallets.getBalance,
 
@@ -127,6 +130,15 @@ export const api = {
     buildSwapTransaction: swap.buildSwapTransaction,
     registerKotlinSwapProvider: swap.registerKotlinSwapProvider,
 
+    createTonApiGaslessProvider: gasless.createTonApiGaslessProvider,
+    registerGaslessProvider: gasless.registerGaslessProvider,
+    setDefaultGaslessProvider: gasless.setDefaultGaslessProvider,
+    getRegisteredGaslessProviders: gasless.getRegisteredGaslessProviders,
+    hasGaslessProvider: gasless.hasGaslessProvider,
+    getGaslessMetadata: gasless.getGaslessMetadata,
+    getGaslessConfig: gasless.getGaslessConfig,
+    getGaslessQuote: gasless.getGaslessQuote,
+    gaslessSendTransaction: gasless.gaslessSendTransaction,
     walletClientSendBoc: walletClient.walletClientSendBoc,
     walletClientRunGetMethod: walletClient.walletClientRunGetMethod,
     walletClientGetBalance: walletClient.walletClientGetBalance,

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

@@ -132,6 +132,14 @@ export async function getWalletNetwork(args: { walletId: string }) {
     return wallet(args.walletId, 'getNetwork');
 }
 
+export async function getWalletPublicKey(args: { walletId: string }) {
+    return wallet(args.walletId, 'getPublicKey');
+}
+
+export async function getSignedSignMessage(args: { walletId: string; request: TransactionRequest }) {
+    return wallet(args.walletId, 'getSignedSignMessage', args.request);
+}
+
 export async function removeWallet(args: { walletId: string }) {
     return kit('removeWallet', args.walletId);
 }

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

@@ -33,6 +33,7 @@ import type {
 } from '@ton/walletkit';
 import type { DeDustSwapProviderConfig } from '@ton/walletkit/swap/dedust';
 import type { OmnistonSwapProviderConfig } from '@ton/walletkit/swap/omniston';
+import type { TonApiGaslessProviderConfig } from '@ton/walletkit/gasless/tonapi';
 
 import type { TONBase64, TONHex, TONUserFriendlyAddress } from './brands';
 import type { WalletKitBridgeEventCallback } from './events';
@@ -429,6 +430,41 @@ export interface BuildSwapTransactionArgs {
     params: Record<string, unknown>;
 }
 
+export interface CreateTonApiGaslessProviderArgs {
+    config?: TonApiGaslessProviderConfig;
+}
+
+export interface RegisterGaslessProviderArgs {
+    providerId: string;
+}
+
+export interface SetDefaultGaslessProviderArgs {
+    providerId: string;
+}
+
+export interface HasGaslessProviderArgs {
+    providerId: string;
+}
+
+export interface GetGaslessMetadataArgs {
+    providerId?: string;
+}
+
+export interface GetGaslessConfigArgs {
+    network?: Record<string, unknown>;
+    providerId?: string;
+}
+
+export interface GetGaslessQuoteArgs {
+    params: Record<string, unknown>;
+    providerId?: string;
+}
+
+export interface GaslessSendTransactionArgs {
+    params: Record<string, unknown>;
+    providerId?: string;
+}
+
 export interface WalletKitBridgeApi {
     init(config?: WalletKitBridgeInitConfig): PromiseOrValue<{ ok: true }>;
     setEventsListeners(args?: SetEventsListenersArgs): PromiseOrValue<{ ok: true }>;
@@ -454,6 +490,8 @@ export interface WalletKitBridgeApi {
     getWallets(): PromiseOrValue<{ walletId: string | undefined; wallet: Wallet }[]>;
     getWallet(args: { walletId: string }): PromiseOrValue<{ walletId: string | undefined; wallet: Wallet } | null>;
     getWalletAddress(args: { walletId: string }): PromiseOrValue<TONUserFriendlyAddress | null>;
+    getWalletPublicKey(args: { walletId: string }): PromiseOrValue<TONHex>;
+    getSignedSignMessage(args: { walletId: string; request: Record<string, unknown> }): PromiseOrValue<unknown>;
     removeWallet(args: RemoveWalletArgs): PromiseOrValue<void>;
     getBalance(args: GetBalanceArgs): PromiseOrValue<string | undefined>;
     getRecentTransactions(args: GetRecentTransactionsArgs): PromiseOrValue<Transaction[]>;
@@ -531,6 +569,15 @@ export interface WalletKitBridgeApi {
     getSwapQuote(args: GetSwapQuoteArgs): PromiseOrValue<unknown>;
     buildSwapTransaction(args: BuildSwapTransactionArgs): PromiseOrValue<unknown>;
     registerKotlinSwapProvider(args: RegisterKotlinSwapProviderArgs): PromiseOrValue<void>;
+    createTonApiGaslessProvider(args?: CreateTonApiGaslessProviderArgs): PromiseOrValue<{ providerId: string }>;
+    registerGaslessProvider(args: RegisterGaslessProviderArgs): PromiseOrValue<void>;
+    setDefaultGaslessProvider(args: SetDefaultGaslessProviderArgs): PromiseOrValue<void>;
+    getRegisteredGaslessProviders(): PromiseOrValue<{ providerIds: string[] }>;
+    hasGaslessProvider(args: HasGaslessProviderArgs): PromiseOrValue<{ result: boolean }>;
+    getGaslessMetadata(args: GetGaslessMetadataArgs): PromiseOrValue<unknown>;
+    getGaslessConfig(args: GetGaslessConfigArgs): PromiseOrValue<unknown>;
+    getGaslessQuote(args: GetGaslessQuoteArgs): PromiseOrValue<unknown>;
+    gaslessSendTransaction(args: GaslessSendTransactionArgs): PromiseOrValue<unknown>;
 
     // Per-wallet ApiClient proxy: Android `BridgedJSAPIClient` round-trips
     // `wallet.client.<method>` through these so the underlying JS `ApiClient`