@ton/appkit 0.0.1-alpha.2 → 0.0.2

package/src/actions/nft/get-nfts.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 { NFTsResponse, Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { getNftsByAddress } from './get-nfts-by-address';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface GetNftsOptions {
+    network?: Network;
+    limit?: number;
+    offset?: number;
+}
+
+export type GetNftsReturnType = NFTsResponse | null;
+
+export const getNfts = async (appKit: AppKit, options: GetNftsOptions = {}): Promise<GetNftsReturnType> => {
+    const selectedWallet = getSelectedWallet(appKit);
+
+    if (!selectedWallet) {
+        return null;
+    }
+
+    return getNftsByAddress(appKit, {
+        address: selectedWallet.getAddress(),
+        network: options.network,
+        limit: options.limit,
+        offset: options.offset,
+    });
+};

package/src/actions/nft/transfer-nft.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 { SendTransactionResponse } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { createTransferNftTransaction } from './create-transfer-nft-transaction';
+import type { CreateTransferNftTransactionParameters } from './create-transfer-nft-transaction';
+import { sendTransaction } from '../transaction/send-transaction';
+
+export type TransferNftParameters = CreateTransferNftTransactionParameters;
+
+export type TransferNftReturnType = SendTransactionResponse;
+
+/**
+ * Transfer NFT to another wallet
+ */
+export const transferNft = async (
+    appKit: AppKit,
+    parameters: TransferNftParameters,
+): Promise<TransferNftReturnType> => {
+    const transaction = await createTransferNftTransaction(appKit, parameters);
+
+    return sendTransaction(appKit, transaction);
+};

package/src/actions/providers/register-provider.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 { Provider } from '../../types/provider';
+import type { AppKit } from '../../core/app-kit';
+
+export type RegisterProviderOptions = Provider;
+
+/**
+ * Register provider
+ */
+export const registerProvider = (appKit: AppKit, provider: RegisterProviderOptions): void => {
+    appKit.registerProvider(provider);
+};

package/src/actions/signing/sign-binary.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 { Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import type { SignDataResponse } from '../../types/signing';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+import type { Base64String } from '../../types/primitives';
+
+export interface SignBinaryParameters {
+    /** Binary data to sign (base64 encoded) */
+    bytes: Base64String;
+    /** Optional network (mainnet/testnet) */
+    network?: Network;
+}
+
+export type SignBinaryReturnType = SignDataResponse;
+
+/**
+ * Sign binary data with the connected wallet.
+ *
+ * @example
+ * ```ts
+ * const result = await signBinary(appKit, { bytes: btoa("binary data") });
+ * console.log(result.signature);
+ * ```
+ */
+export const signBinary = async (appKit: AppKit, parameters: SignBinaryParameters): Promise<SignBinaryReturnType> => {
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    return await wallet.signData({
+        network: parameters.network,
+        data: {
+            type: 'binary',
+            value: { content: parameters.bytes },
+        },
+    });
+};

package/src/actions/signing/sign-cell.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import type { SignDataResponse } from '../../types/signing';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+import type { Base64String } from '../../types/primitives';
+
+export interface SignCellParameters {
+    /** Base64 encoded Bag of Cells */
+    cell: Base64String;
+    /** TL-B schema for the cell structure */
+    schema: string;
+    /** Optional network (mainnet/testnet) */
+    network?: Network;
+}
+
+export type SignCellReturnType = SignDataResponse;
+
+/**
+ * Sign a TON Cell with the connected wallet.
+ * Used for on-chain signature verification.
+ *
+ * @example
+ * ```ts
+ * const result = await signCell(appKit, {
+ *   cell: bocBase64,
+ *   schema: "transfer#abc123 amount:uint64 = Transfer"
+ * });
+ * console.log(result.signature);
+ * ```
+ */
+export const signCell = async (appKit: AppKit, parameters: SignCellParameters): Promise<SignCellReturnType> => {
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    return await wallet.signData({
+        network: parameters.network,
+        data: {
+            type: 'cell',
+            value: {
+                content: parameters.cell,
+                schema: parameters.schema,
+            },
+        },
+    });
+};

package/src/actions/signing/sign-text.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import type { SignDataResponse } from '../../types/signing';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface SignTextParameters {
+    /** Text message to sign */
+    text: string;
+    /** Optional network (mainnet/testnet) */
+    network?: Network;
+}
+
+export type SignTextReturnType = SignDataResponse;
+
+/**
+ * Sign a text message with the connected wallet.
+ *
+ * @example
+ * ```ts
+ * const result = await signText(appKit, { text: "Hello World" });
+ * console.log(result.signature);
+ * ```
+ */
+export const signText = async (appKit: AppKit, parameters: SignTextParameters): Promise<SignTextReturnType> => {
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    return await wallet.signData({
+        network: parameters.network,
+        data: {
+            type: 'text',
+            value: { content: parameters.text },
+        },
+    });
+};

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/get-transaction-status.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { TransactionStatusResponse } from '@ton/walletkit';
+import { getTransactionStatus as walletKitGetTransactionStatus } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { Network } from '../../types/network';
+
+export type GetTransactionStatusParameters = {
+    /** Network to check the transaction on */
+    network?: Network;
+} & (
+    | {
+          /** BOC of the sent transaction (base64) */
+          boc: string;
+          /** Hash of the sent transaction (hex) */
+          normalizedHash?: never;
+      }
+    | {
+          /** BOC of the sent transaction (base64) */
+          boc?: never;
+          /** Normalized Hash of the external-in transaction (hex) */
+          normalizedHash: string;
+      }
+);
+
+export type GetTransactionStatusReturnType = TransactionStatusResponse;
+
+export type GetTransactionStatusErrorType = Error;
+
+/**
+ * Get the status of a transaction by its BOC.
+ *
+ * In TON, a single external message triggers a tree of internal messages.
+ * The transaction is "complete" only when the entire trace finishes.
+ * This action checks toncenter's trace endpoints to determine the current status.
+ *
+ * @example
+ * ```ts
+ * const result = await sendTransaction(appKit, { messages: [...] });
+ * const status = await getTransactionStatus(appKit, { boc: result.boc });
+ * // status.status === 'pending' | 'completed' | 'failed'
+ * // status.completedMessages === 3
+ * // status.totalMessages === 5
+ * ```
+ */
+export const getTransactionStatus = async (
+    appKit: AppKit,
+    parameters: GetTransactionStatusParameters,
+): Promise<GetTransactionStatusReturnType> => {
+    const { boc, normalizedHash, network } = parameters;
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    if (boc) {
+        return walletKitGetTransactionStatus(client, { boc });
+    }
+
+    if (normalizedHash) {
+        return walletKitGetTransactionStatus(client, { normalizedHash });
+    }
+
+    throw new Error('Either boc or normalizedHash must be provided');
+};

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;
+};