@ton/appkit 0.0.1-alpha.2 → 0.0.2

package/src/actions/index.ts

@@ -0,0 +1,140 @@
+/**
+ * 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.
+ *
+ */
+
+// Balances
+export {
+    getBalanceByAddress,
+    type GetBalanceByAddressOptions,
+    type GetBalanceByAddressReturnType,
+} from './balances/get-balance-by-address';
+export { getBalance, type GetBalanceOptions, type GetBalanceReturnType } from './balances/get-balance';
+
+// Connectors
+export { addConnector, type AddConnectorParameters, type AddConnectorReturnType } from './connectors/add-connector';
+export { connect, type ConnectParameters, type ConnectReturnType } from './connectors/connect';
+export { disconnect, type DisconnectReturnType, type DisconnectParameters } from './connectors/disconnect';
+export { getConnectors, type GetConnectorsReturnType } from './connectors/get-connectors';
+export {
+    watchConnectors,
+    type WatchConnectorsParameters,
+    type WatchConnectorsReturnType,
+} from './connectors/watch-connectors';
+export {
+    getConnectorById,
+    type GetConnectorByIdOptions,
+    type GetConnectorByIdReturnType,
+} from './connectors/get-connector-by-id';
+export {
+    watchConnectorById,
+    type WatchConnectorByIdParameters,
+    type WatchConnectorByIdReturnType,
+} from './connectors/watch-connector-by-id';
+
+// Jettons
+export { getJettonInfo, type GetJettonInfoOptions, type GetJettonInfoReturnType } from './jettons/get-jetton-info';
+export {
+    getJettonWalletAddress,
+    type GetJettonWalletAddressOptions,
+    type GetJettonWalletAddressReturnType,
+} from './jettons/get-jetton-wallet-address';
+export {
+    getJettonBalance,
+    type GetJettonBalanceOptions,
+    type GetJettonBalanceReturnType,
+} from './jettons/get-jetton-balance';
+export {
+    getJettonsByAddress,
+    type GetJettonsByAddressOptions,
+    type GetJettonsByAddressReturnType,
+} from './jettons/get-jettons-by-address';
+export { getJettons, type GetJettonsOptions, type GetJettonsReturnType } from './jettons/get-jettons';
+export {
+    createTransferJettonTransaction,
+    type CreateTransferJettonTransactionParameters,
+    type CreateTransferJettonTransactionReturnType,
+} from './jettons/create-transfer-jetton-transaction';
+export {
+    transferJetton,
+    type TransferJettonParameters,
+    type TransferJettonReturnType,
+} from './jettons/transfer-jetton';
+
+// Network
+export { getNetworks, type GetNetworksReturnType } from './network/get-networks';
+export { getNetwork, type GetNetworkReturnType } from './network/get-network';
+export { watchNetworks, type WatchNetworksParameters, type WatchNetworksReturnType } from './network/watch-networks';
+
+// NFT
+export {
+    getNftsByAddress,
+    type GetNftsByAddressOptions,
+    type GetNftsByAddressReturnType,
+} from './nft/get-nfts-by-address';
+export { getNfts, type GetNftsOptions, type GetNftsReturnType } from './nft/get-nfts';
+export { getNft, type GetNftOptions, type GetNftReturnType } from './nft/get-nft';
+export { transferNft, type TransferNftParameters, type TransferNftReturnType } from './nft/transfer-nft';
+
+// Providers
+export { registerProvider, type RegisterProviderOptions } from './providers/register-provider';
+
+// Signing
+export { signText, type SignTextParameters, type SignTextReturnType } from './signing/sign-text';
+export { signBinary, type SignBinaryParameters, type SignBinaryReturnType } from './signing/sign-binary';
+export { signCell, type SignCellParameters, type SignCellReturnType } from './signing/sign-cell';
+
+// Swap
+export { getSwapManager, type GetSwapManagerReturnType } from './swap/get-swap-manager';
+export { getSwapQuote, type GetSwapQuoteOptions, type GetSwapQuoteReturnType } from './swap/get-swap-quote';
+export {
+    buildSwapTransaction,
+    type BuildSwapTransactionOptions,
+    type BuildSwapTransactionReturnType,
+} from './swap/build-swap-transaction';
+
+// Transactions
+export {
+    sendTransaction,
+    type SendTransactionParameters,
+    type SendTransactionReturnType,
+} from './transaction/send-transaction';
+export { transferTon, type TransferTonParameters, type TransferTonReturnType } from './transaction/transfer-ton';
+export {
+    getTransactionStatus,
+    type GetTransactionStatusParameters,
+    type GetTransactionStatusReturnType,
+    type GetTransactionStatusErrorType,
+} from './transaction/get-transaction-status';
+export {
+    createTransferNftTransaction,
+    type CreateTransferNftTransactionParameters,
+    type CreateTransferNftTransactionReturnType,
+} from './nft/create-transfer-nft-transaction';
+export {
+    createTransferTonTransaction,
+    type CreateTransferTonTransactionParameters,
+    type CreateTransferTonTransactionReturnType,
+} from './transaction/create-transfer-ton-transaction';
+
+// Wallets
+export { getConnectedWallets, type GetConnectedWalletsReturnType } from './wallets/get-connected-wallets';
+export { getSelectedWallet, type GetSelectedWalletReturnType } from './wallets/get-selected-wallet';
+export {
+    setSelectedWalletId,
+    type SetSelectedWalletIdParameters,
+    type SetSelectedWalletIdReturnType,
+} from './wallets/set-selected-wallet-id';
+export {
+    watchSelectedWallet,
+    type WatchSelectedWalletParameters,
+    type WatchSelectedWalletReturnType,
+} from './wallets/watch-selected-wallet';
+export {
+    watchConnectedWallets,
+    type WatchConnectedWalletsParameters,
+    type WatchConnectedWalletsReturnType,
+} from './wallets/watch-connected-wallets';

package/src/actions/jettons/create-transfer-jetton-transaction.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 {
+    createJettonTransferPayload,
+    createTransferTransaction,
+    getJettonWalletAddressFromClient,
+    DEFAULT_JETTON_GAS_FEE,
+    parseUnits,
+} from '@ton/walletkit';
+
+import type { TransactionRequest } from '../../types/transaction';
+import type { AppKit } from '../../core/app-kit';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface CreateTransferJettonTransactionParameters {
+    jettonAddress: string;
+    recipientAddress: string;
+    amount: string;
+    jettonDecimals: number;
+    comment?: string;
+}
+
+export type CreateTransferJettonTransactionReturnType = TransactionRequest;
+
+/**
+ * Create a Jetton transfer transaction request
+ */
+export const createTransferJettonTransaction = async (
+    appKit: AppKit,
+    parameters: CreateTransferJettonTransactionParameters,
+): Promise<CreateTransferJettonTransactionReturnType> => {
+    const { jettonAddress, recipientAddress, amount, jettonDecimals, comment } = parameters;
+
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    // Get client from network manager
+    const client = appKit.networkManager.getClient(wallet.getNetwork());
+
+    // Get jetton wallet address
+    const jettonWalletAddress = await getJettonWalletAddressFromClient(client, jettonAddress, wallet.getAddress());
+
+    // Create jetton transfer payload
+    const jettonPayload = createJettonTransferPayload({
+        amount: parseUnits(amount, jettonDecimals),
+        destination: recipientAddress,
+        responseDestination: wallet.getAddress(),
+        comment,
+    });
+
+    // Build transaction
+    return createTransferTransaction({
+        targetAddress: jettonWalletAddress,
+        amount: DEFAULT_JETTON_GAS_FEE,
+        payload: jettonPayload,
+        fromAddress: wallet.getAddress(),
+    });
+};

package/src/actions/jettons/get-jetton-balance.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { Network, getJettonBalanceFromClient, formatUnits } from '@ton/walletkit';
+import type { TokenAmount, UserFriendlyAddress } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { getJettonWalletAddress } from './get-jetton-wallet-address';
+
+export interface GetJettonBalanceOptions {
+    jettonAddress: UserFriendlyAddress;
+    ownerAddress: UserFriendlyAddress;
+    jettonDecimals: number;
+    network?: Network;
+}
+
+export type GetJettonBalanceReturnType = TokenAmount;
+
+export const getJettonBalance = async (
+    appKit: AppKit,
+    options: GetJettonBalanceOptions,
+): Promise<GetJettonBalanceReturnType> => {
+    const { jettonAddress, ownerAddress, jettonDecimals, network } = options;
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    const jettonWalletAddress = await getJettonWalletAddress(appKit, {
+        jettonAddress,
+        ownerAddress,
+        network,
+    });
+    const balance = await getJettonBalanceFromClient(client, jettonWalletAddress);
+
+    return formatUnits(balance, jettonDecimals);
+};

package/src/actions/jettons/get-jetton-info.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { JettonInfo } from '@ton/walletkit';
+import { Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetJettonInfoOptions {
+    address: string;
+    network?: Network;
+}
+
+export type GetJettonInfoReturnType = JettonInfo | null;
+
+export const getJettonInfo = async (
+    appKit: AppKit,
+    options: GetJettonInfoOptions,
+): Promise<GetJettonInfoReturnType> => {
+    const { address, network } = options;
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    const response = await client.jettonsByAddress({
+        address: address,
+        offset: 0,
+        limit: 1,
+    });
+
+    if (!response.jetton_masters?.length || !response.jetton_masters[0]) {
+        return null;
+    }
+
+    const jetton = response.jetton_masters[0];
+    const metadata = response.metadata?.[jetton.address];
+    const tokenInfo = metadata?.token_info?.find((t) => t.valid && t.type === 'jetton_masters') as
+        | {
+              name?: string;
+              symbol?: string;
+              description?: string;
+              image?: string;
+              extra?: { decimals?: string | number; uri?: string };
+          }
+        | undefined;
+
+    let decimals: number | undefined;
+    if (tokenInfo?.extra?.decimals !== undefined) {
+        try {
+            decimals =
+                typeof tokenInfo.extra.decimals === 'string'
+                    ? parseInt(tokenInfo.extra.decimals, 10)
+                    : tokenInfo.extra.decimals;
+        } catch {
+            // ignore
+        }
+    }
+
+    return {
+        decimals,
+        address: jetton.jetton,
+        name: tokenInfo?.name ?? '',
+        symbol: tokenInfo?.symbol ?? '',
+        description: tokenInfo?.description ?? '',
+        image: tokenInfo?.image,
+        uri: tokenInfo?.extra?.uri,
+    };
+};

package/src/actions/jettons/get-jetton-wallet-address.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.
+ *
+ */
+
+import { Network, getJettonWalletAddressFromClient } from '@ton/walletkit';
+import type { UserFriendlyAddress } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetJettonWalletAddressOptions {
+    jettonAddress: UserFriendlyAddress;
+    ownerAddress: UserFriendlyAddress;
+    network?: Network;
+}
+
+export type GetJettonWalletAddressReturnType = UserFriendlyAddress;
+
+export const getJettonWalletAddress = async (
+    appKit: AppKit,
+    options: GetJettonWalletAddressOptions,
+): Promise<GetJettonWalletAddressReturnType> => {
+    const { jettonAddress, ownerAddress, network } = options;
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    return getJettonWalletAddressFromClient(client, jettonAddress, ownerAddress);
+};

package/src/actions/jettons/get-jettons-by-address.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 { Jetton, JettonsResponse } from '@ton/walletkit';
+import { Network, getJettonsFromClient, formatUnits } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetJettonsByAddressOptions {
+    address: string | Address;
+    network?: Network;
+    limit?: number;
+    offset?: number;
+}
+
+export type GetJettonsByAddressReturnType = JettonsResponse;
+
+export const getJettonsByAddress = async (
+    appKit: AppKit,
+    options: GetJettonsByAddressOptions,
+): Promise<GetJettonsByAddressReturnType> => {
+    const { address, network, limit, offset } = options;
+    const addressString = Address.isAddress(address) ? address.toString() : Address.parse(address).toString();
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+    const response = await getJettonsFromClient(client, addressString, {
+        pagination: {
+            limit,
+            offset,
+        },
+    });
+
+    const jettons = response.jettons.reduce((acc, jetton) => {
+        if (!jetton.decimalsNumber) {
+            return acc;
+        }
+
+        acc.push({
+            ...jetton,
+            balance: formatUnits(jetton.balance, jetton.decimalsNumber),
+        });
+        return acc;
+    }, [] as Jetton[]);
+
+    return {
+        ...response,
+        jettons,
+    };
+};

package/src/actions/jettons/get-jettons.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 { JettonsResponse, Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+import { getJettonsByAddress } from './get-jettons-by-address';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface GetJettonsOptions {
+    network?: Network;
+    limit?: number;
+    offset?: number;
+}
+
+export type GetJettonsReturnType = JettonsResponse | null;
+
+export const getJettons = async (appKit: AppKit, options: GetJettonsOptions = {}): Promise<GetJettonsReturnType> => {
+    const selectedWallet = getSelectedWallet(appKit);
+
+    if (!selectedWallet) {
+        return null;
+    }
+
+    return getJettonsByAddress(appKit, {
+        address: selectedWallet.getAddress(),
+        network: options.network,
+        limit: options.limit,
+        offset: options.offset,
+    });
+};

package/src/actions/jettons/transfer-jetton.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 { createTransferJettonTransaction } from './create-transfer-jetton-transaction';
+import type { CreateTransferJettonTransactionParameters } from './create-transfer-jetton-transaction';
+import { sendTransaction } from '../transaction/send-transaction';
+
+export type TransferJettonParameters = CreateTransferJettonTransactionParameters;
+
+export type TransferJettonReturnType = SendTransactionResponse;
+
+export type TransferJettonErrorType = Error;
+
+/**
+ * Transfer Jetton - creates and sends a Jetton transfer transaction
+ */
+export const transferJetton = async (
+    appKit: AppKit,
+    parameters: TransferJettonParameters,
+): Promise<TransferJettonReturnType> => {
+    const transaction = await createTransferJettonTransaction(appKit, parameters);
+
+    return sendTransaction(appKit, transaction);
+};

package/src/actions/network/get-network.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export type GetNetworkReturnType = Network | null;
+
+/**
+ * Get the network of the currently selected wallet
+ */
+export const getNetwork = (appKit: AppKit): GetNetworkReturnType => {
+    const wallet = getSelectedWallet(appKit);
+
+    return wallet?.getNetwork() ?? null;
+};

package/src/actions/network/get-networks.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 { Network } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export type GetNetworksReturnType = Network[];
+
+/**
+ * Get all configured networks
+ */
+export const getNetworks = (appKit: AppKit): GetNetworksReturnType => {
+    return appKit.networkManager.getConfiguredNetworks();
+};

package/src/actions/network/watch-networks.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 { Network } from '@ton/walletkit';
+
+import { getNetworks } from './get-networks';
+import type { AppKit } from '../../core/app-kit';
+import { NETWORKS_EVENTS } from '../../core/app-kit';
+
+export type WatchNetworksParameters = {
+    onChange: (networks: Network[]) => void;
+};
+
+export type WatchNetworksReturnType = () => void;
+
+/**
+ * Watch configured networks
+ */
+export const watchNetworks = (appKit: AppKit, parameters: WatchNetworksParameters): WatchNetworksReturnType => {
+    const { onChange } = parameters;
+
+    const unsubscribe = appKit.emitter.on(NETWORKS_EVENTS.UPDATED, () => {
+        onChange(getNetworks(appKit));
+    });
+
+    return unsubscribe;
+};

package/src/actions/nft/create-transfer-nft-transaction.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { createNftTransferPayload, createTransferTransaction, DEFAULT_NFT_GAS_FEE } from '@ton/walletkit';
+
+import type { TransactionRequest } from '../../types/transaction';
+import type { AppKit } from '../../core/app-kit';
+import { getSelectedWallet } from '../wallets/get-selected-wallet';
+
+export interface CreateTransferNftTransactionParameters {
+    nftAddress: string;
+    recipientAddress: string;
+    amount?: string;
+    comment?: string;
+}
+
+export type CreateTransferNftTransactionReturnType = TransactionRequest;
+
+/**
+ * Create a NFT transfer transaction request
+ */
+export const createTransferNftTransaction = async (
+    appKit: AppKit,
+    parameters: CreateTransferNftTransactionParameters,
+): Promise<CreateTransferNftTransactionReturnType> => {
+    const { nftAddress, recipientAddress, amount, comment } = parameters;
+
+    const wallet = getSelectedWallet(appKit);
+
+    if (!wallet) {
+        throw new Error('Wallet not connected');
+    }
+
+    const payload = createNftTransferPayload({
+        newOwner: recipientAddress,
+        responseDestination: wallet.getAddress(),
+        comment,
+    });
+
+    return createTransferTransaction({
+        targetAddress: nftAddress,
+        amount: amount ?? DEFAULT_NFT_GAS_FEE,
+        payload,
+        fromAddress: wallet.getAddress(),
+    });
+};

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

@@ -0,0 +1,29 @@
+/**
+ * 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 { NFT } from '@ton/walletkit';
+import { Network, getNftFromClient } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetNftOptions {
+    address: string | Address;
+    network?: Network;
+}
+
+export type GetNftReturnType = NFT | null;
+
+export const getNft = async (appKit: AppKit, options: GetNftOptions): Promise<GetNftReturnType> => {
+    const { address, network } = options;
+    const addressString = Address.isAddress(address) ? address.toString() : Address.parse(address).toString();
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    return getNftFromClient(client, addressString);
+};

package/src/actions/nft/get-nfts-by-address.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 { Address } from '@ton/core';
+import type { NFTsResponse } from '@ton/walletkit';
+import { Network, getNftsFromClient } from '@ton/walletkit';
+
+import type { AppKit } from '../../core/app-kit';
+
+export interface GetNftsByAddressOptions {
+    address: string | Address;
+    network?: Network;
+    limit?: number;
+    offset?: number;
+}
+
+export type GetNftsByAddressReturnType = NFTsResponse;
+
+export const getNftsByAddress = async (
+    appKit: AppKit,
+    options: GetNftsByAddressOptions,
+): Promise<GetNftsByAddressReturnType> => {
+    const { address, network, limit, offset } = options;
+    const addressString = Address.isAddress(address) ? address.toString() : Address.parse(address).toString();
+
+    const client = appKit.networkManager.getClient(network ?? Network.mainnet());
+
+    return getNftsFromClient(client, addressString, {
+        pagination: {
+            limit,
+            offset,
+        },
+    });
+};