# TON Provider

The Tomo Telegram SDK provides a TON Provider for querying account data and sending transactions.

## Connect with the Wallet[​](https://docs.uxuy.com/uxuy-connect/guide/#isconnected) <a href="#isconnected" id="isconnected"></a>

Before using the provider, the user needs to log in to the wallet through the modal by following the method:

```typescript
// connect wallet
await ton?.connectWallet();
```

We also support connecting through TON proof:

```typescript
// the tonProof must be a hex string
const res = await tomo_ton.connect({
  tonProof: Buffer.from('your challenge', 'utf8').toString('hex'),
});

//At the dapp backend, check the tonProof res
const { tonProof } = res;
```

We also support connecting to the TON testnet as follows:

```typescript
// You must use the Tomo TON provider to connect the testnet.
// Other wallet providers through TON Connect do not work.
const res = await tomo_ton.connect({
  network: 'testnet'
});
```

## Query Methods

TON provider supports two query methods:

* `getAddress`
* `getBalance`

<pre class="language-typescript"><code class="lang-typescript"><strong>const address = ton.getAddress();
</strong><strong>
</strong>const balance = await ton.getBalance(address);
</code></pre>

## Sending Methods

In TON providers, we provide one send methods:

* `sendTransaction`

This method allows signing and sending transactions in one call. The input for this method is `TonTxParams,` defined as the following:

```typescript
export interface TonTxParams {
  valid_until?: number | bigint;
  validUntil?: number | bigint;
  network?: string;
  from?: string;
  messages: {
    address: string;
    amount: string; // nanoTon,  e.g. toNano('0.1').toString()
    stateInit?: string;
    payload?: string;
  }[];
}
// !amount must be nanoTon, 
```

You can construct your payload as a BOC(Bag of Cells) in the same way as the standard one.\
Then, convert it into a **base64 string** or **hexadecimal string** and pass it to `sendTx` method.

```typescript
tomo_ton.sendTransaction(txParam: TonTxParams)
```

### Payload for TON transaction

You can create a general [payload ](https://docs.ton.org/v3/guidelines/ton-connect/guidelines/preparing-messages)using `@ton/core`

```typescript
import { beginCell, toNano, Address } from '@ton/core';
const createPayloadByTonCoreCell = async (tokenAmount, recipientAddress: string) => {
    const destinationAddress = Address.parse(recipientAddress);

    const body = beginCell()
    .storeUint(0xf8a7ea5, 32) // Operation code for transferring
    .storeUint(0, 64) // / Query ID (can be any unique identifier)
    .storeCoins(tokenAmount) // Amount of tokens to send
    .storeAddress(destinationAddress) // destination
    .storeAddress(destinationAddress) // response_destination
    .storeBit(false) // null custom_payload
    .storeCoins(toNano('0.000001'))
    .storeBit(false) // false for empty forward payload
    .endCell();

    return body.toBoc().toString('base64');
};
```

Or `tonweb:`

```typescript
import TonWeb from 'tonweb';
const createPayloadByTonWebCell = async (tokenAmount, recipientAddress) => {
    const tonWeb = new TonWeb(new TonWeb.HttpProvider());
    const cell = new tonWeb.boc.Cell();

    cell.bits.writeUint(0xf8a7ea5, 32); // Operation code for transferring tokens
    cell.bits.writeUint(0, 64); // Query ID (can be any unique identifier)
    cell.bits.writeCoins(tokenAmount); // Amount of tokens to send
    cell.bits.writeAddress(new TonWeb.utils.Address(recipientAddress)); // recipient address
    cell.bits.writeAddress(new TonWeb.utils.Address(recipientAddress)); // response address
    cell.bits.writeBit(false);  // null custom_payload
    cell.bits.writeCoins(TonWeb.utils.toNano('0.0001')); // forwardAmount
    cell.bits.writeBit(false); // empty forward payload

    return Buffer.from(await cell.toBoc()).toString('base64');
};
```

### Payload for Jetton transaction

Below is an example use `JettonWallet` under `tonweb` for transferring jetton:

```typescript
const createJettonTransferPayload = async (
    tokenAmount,
    recipientAddress,
  ) => {
    const tonWeb = new TonWeb(new TonWeb.HttpProvider());
    const jettonWallet = new TonWeb.token.jetton.JettonWallet(
        tonWeb.provider,
        {}
    );
    const transferBody = await jettonWallet.createTransferBody({
        queryId: 0,
        jettonAmount: tokenAmount,
        toAddress: new TonWeb.utils.Address(recipientAddress),
        forwardAmount: TonWeb.utils.toNano('0.0001'),
        responseAddress: new TonWeb.utils.Address(recipientAddress),
    });
    const uint8 = await transferBody.toBoc();
    return Buffer.from(uint8).toString('base64');
};
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tomo.inc/tomo-sdk/tomo-telegram-sdk/wallet-provider/ton-provider.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.