├── bot.ts
├── commands-handlers.ts
├── connect-wallet-menu.ts
├── main.ts
├── ton-connect
│   ├── connector.ts
│   ├── storage.ts
│   └── wallets.ts
└── utils.ts

import TelegramBot from 'node-telegram-bot-api';
import * as process from 'process';

const token = process.env.TELEGRAM_BOT_TOKEN!;

export const bot = new TelegramBot(token, { polling: true });

async function main(): Promise<void> {    

		...
    bot.onText(/\/start/, (msg: TelegramBot.Message) => {
        bot.sendMessage(
            msg.chat.id,
            `
This is an example of a telegram bot for connecting to TON wallets and sending transactions with TonConnect.

Commands list:
/connect - Connect to a wallet
/my_wallet - Show connected wallet
/send_tx - Send transaction
/disconnect - Disconnect from the wallet

GitHub: https://github.com/ton-connect/demo-telegram-bot
`
        );
    });
}

import TonConnect from '@tonconnect/sdk';
...
export function getConnector(
    chatId: number,
    onConnectorExpired?: (connector: TonConnect) => void
): TonConnect {
    ...
        storedItem = {
            connector: new TonConnect({
                manifestUrl: process.env.MANIFEST_URL,
                storage: new TonConnectStorage(chatId)
            }),
            onConnectorExpired: []
        } as unknown as StoredConnectorData;

    ...
}

import { isWalletInfoRemote, WalletInfoRemote, WalletsListManager } from '@tonconnect/sdk';
export async function getWallets(): Promise<WalletInfoRemote[]> {    const wallets = await walletsListManager.getWallets();    return wallets.filter(isWalletInfoRemote);}

...import { getConnector } from './ton-connect/connector';...
export async function handleConnectCommand(msg: TelegramBot.Message): Promise<void> {    ...    const connector = getConnector(chatId, () => {        unsubscribe();        newConnectRequestListenersMap.delete(chatId);        deleteMessage();    });    ...    const wallets = await getWallets();
    const link = connector.connect(wallets);    ... }

MNEMONIC= word1 word2 word3 word4

Ton-Counter├─ .gitignore├─ .env.example├─ contracts│  ├─ counter.fc│  └─ imports│     └─ stdlib.fc├─ jest.config.ts├─ package-lock.json├─ package.json├─ README.md├─ scripts│  ├─ deployCounter.ts│  ├─ getCounter.ts│  └─ sendIncrement.ts├─ tests│  └─ Counter.spec.ts├─ tsconfig.json└─ wrappers   ├─ Counter.compile.ts   └─ Counter.ts

#include "imports/stdlib.fc";
(int) load_data() inline {                   ;; read function declaration - returns int as result    var ds = get_data().begin_parse();       ;; load the storage cell and start parsing as a slice    return (ds~load_uint(64));               ;; read a 64 bit unsigned int from the slice and return it}
() save_data(int counter) impure inline {    ;; write function declaration - takes an int as arg    set_data(begin_cell()                    ;; store the storage cell and create it with a builder    .store_uint(counter, 64)                 ;; write a 64 bit unsigned int to the builder    .end_cell());                            ;; convert the builder to a cell}
() recv_internal(int msg_value, cell in_msg, slice in_msg_body) impure {  ;; well known function signature    if (in_msg_body.slice_empty?()) {         ;; check if incoming message is empty (with no body)        return ();                            ;; return successfully and accept an empty message    }    int op = in_msg_body~load_uint(32);       ;; parse the operation type encoded in the beginning of msg body    var (counter) = load_data();              ;; call our read utility function to load values from storage    if (op == 1) {                            ;; handle op#1 = increment        save_data(counter + 1);               ;; call our write utility function to persist values to storage    }}
int counter() method_id {          ;; getter declaration - returns int as result    var (counter) = load_data();   ;; call our read utility function to load value    return counter;}

export default class Counter implements Contract {
  static createForDeploy(code: Cell, initialCounterValue: number): Counter {    const data = beginCell()      .storeUint(initialCounterValue, 64)      .endCell();    const workchain = 0;// deploy to workchain 0    const address = contractAddress(workchain, { code, data });    return new Counter(address, { code, data });  }  constructor(readonly address: Address, readonly init?: { code: Cell, data: Cell }) {}
  async sendDeploy(provider: ContractProvider, via: Sender) {    await provider.internal(via, {      value: "0.01",// send 0.01 TON to contract for rent      bounce: false    });  }  async sendIncrement(provider: ContractProvider, via: Sender) {    const messageBody = beginCell()      .storeUint(1, 32)// op (op #1 = increment)      .storeUint(0, 64)// query id      .endCell();    await provider.internal(via, {      value: "0.002",// send 0.002 TON for gas      body: messageBody    });  }
  async getCounter(provider: ContractProvider) {    const { stack } = await provider.get("counter", []);    return stack.readBigNumber();  }}

export async function run() {// initialize ton rpc client on testnet    const endpoint = await getHttpEndpoint({ network: "testnet" });    const client = new TonClient({ endpoint });
// prepare Counter's initial code and data cells for deployment    const counterCode = Cell.fromBoc(fs.readFileSync("build/counter.cell"))[0];// compilation output from step 6    const initialCounterValue = Date.now();// to avoid collisions use current number of milliseconds since epoch as initial value    const counter = Counter.createForDeploy(counterCode, initialCounterValue);
// exit if contract is already deployed    console.log("contract address:", counter.address.toString());    if (await client.isContractDeployed(counter.address)) {        return console.log("Counter already deployed");    }
// open wallet v4 (notice the correct wallet version here)    const mnemonic = process.env.MNEMONIC!;// your 24 secret words (replace ... with the rest of the words)    const key = await mnemonicToWalletKey(mnemonic.split(" "));    const wallet = WalletContractV4.create({ publicKey: key.publicKey, workchain: 0 });    if (!await client.isContractDeployed(wallet.address)) {        return console.log("wallet is not deployed");    }
// open wallet and read the current seqno of the wallet    const walletContract = client.open(wallet);    const walletSender = walletContract.sender(key.secretKey);    const seqno = await walletContract.getSeqno();
// send the deploy transaction    const counterContract = client.open(counter);    await counterContract.sendDeploy(walletSender);
// wait until confirmed    let currentSeqno = seqno;    while (currentSeqno == seqno) {        console.log("waiting for deploy transaction to confirm...");        await sleep(1500);        currentSeqno = await walletContract.getSeqno();    }    console.log("deploy transaction confirmed!");}
function sleep(ms: number) {    return new Promise(resolve => setTimeout(resolve, ms));}

export async function run() {// initialize ton rpc client on testnet    const endpoint = await getHttpEndpoint({ network: "testnet" });    const client = new TonClient({ endpoint });
// open Counter instance by address    const counterAddress = Address.parse("EQDYOmv_rQXifWNqkrHzPERRJEBwHyBOplPgXJDGbu7p3mp8");// replace with your address from step 8    const counter = new Counter(counterAddress);    const counterContract = client.open(counter);
// call the getter on chain    const counterValue = await counterContract.getCounter();    console.log("value:", counterValue.toString());}

export async function run() {// initialize ton rpc client on testnet    const endpoint = await getHttpEndpoint({ network: "testnet" });    const client = new TonClient({ endpoint });
// open wallet v4 (notice the correct wallet version here)    const mnemonic = process.env.MNEMONIC!;// your 24 secret words (replace ... with the rest of the words)    const key = await mnemonicToWalletKey(mnemonic.split(" "));    const wallet = WalletContractV4.create({ publicKey: key.publicKey, workchain: 0 });    if (!await client.isContractDeployed(wallet.address)) {        return console.log("wallet is not deployed");    }
// open wallet and read the current seqno of the wallet    const walletContract = client.open(wallet);    const walletSender = walletContract.sender(key.secretKey);    const seqno = await walletContract.getSeqno();
// open Counter instance by address    const counterAddress = Address.parse("EQDYOmv_rQXifWNqkrHzPERRJEBwHyBOplPgXJDGbu7p3mp8");// replace with your address from step 8    const counter = new Counter(counterAddress);    const counterContract = client.open(counter);
// send the increment transaction    await counterContract.sendIncrement(walletSender);
// wait until confirmed    let currentSeqno = seqno;    while (currentSeqno == seqno) {        console.log("waiting for transaction to confirm...");        await sleep(1500);        currentSeqno = await walletContract.getSeqno();    }    console.log("transaction confirmed!");}
function sleep(ms: number) {    return new Promise(resolve => setTimeout(resolve, ms));}

import { TonClient } from '@ton/ton';
export async function handleGetCounterCommand(msg: TelegramBot.Message): Promise<void> {    const chatId = msg.chat.id;
    const client = new TonClient({        endpoint: `https://testnet.toncenter.com/api/v2/jsonRPC`,        apiKey: process.env.TONCENTER_API_KEY,    });
    const contract = new Counter(        Address.parse('EQBYLTm4nsvoqJRvs_L-IGNKwWs5RKe19HBK_lFadf19FUfb')// replace with your address from tutorial 2 step 8      );    const counterContract =  client.open(contract) as unknown  as OpenedContract<Counter>;    const val = await counterContract.getCounter();    console.log(val);    await bot.sendMessage(chatId, 'counter value : ' + val);}

export async function handleIncrementCounterCommand(msg: TelegramBot.Message): Promise<void> {    const chatId = msg.chat.id;
    const connector = getConnector(chatId);
    await connector.restoreConnection();    if (!connector.connected) {        await bot.sendMessage(chatId, "You didn't connect a wallet");        return;    }
    const client = new TonClient({        endpoint: `https://testnet.toncenter.com/api/v2/jsonRPC`,        apiKey: process.env.TONCENTER_API_KEY,    });
    const contract = new Counter(        Address.parse('EQBYLTm4nsvoqJRvs_L-IGNKwWs5RKe19HBK_lFadf19FUfb') // replace with your address from tutorial 2 step 8      );    const counterContract =  client.open(contract) as unknown  as OpenedContract<Counter>;
    const sender = {        send: async (args: SenderArguments) => {            connector.sendTransaction({                network: CHAIN.TESTNET,                validUntil: Math.round(                    (Date.now() + Number(process.env.DELETE_SEND_TX_MESSAGE_TIMEOUT_MS)) / 1000                ),                messages: [                    {                        address: args.to.toString(),                        amount: args.value.toString(),                        payload: args.body?.toBoc().toString('base64'),                    }                ]            });        }    }
    counterContract?.sendIncrement(sender);    //Todo: seqno verfiy
    await bot.sendMessage(chatId, "increment counter success");}

bot.onText(/\/get_counter/, handleGetCounterCommand);bot.onText(/\/increment_counter/, handleIncrementCounterCommand);