6.4 编程命令驱动的机器人界面

riyad

2 C2 ]: B. j% L! j# L8 b* u5 s

在本课中，我们将再创建一个项目--聊天机器人。这将是一个后台项目，因为聊天机器人就是这样工作的。你要编写一些运行在服务器上的脚本。然后使用 API 密钥连接到 Telegram 服务器。当有新消息时，你的脚本可以从 Telegram 服务器获取更新。你可以代表聊天机器人触发新消息。基本上，这就是一个独立的应用程序。

我们拿到了合约，部署了它--这就像是我们 dApp 的后台。然后，我们创建了一个网络接口，这样网络上的任何人都可以访问它并与之互动。然后，我们创建了一个 TWA（Telegram 网络应用程序），将其嵌入到 Telegram 中。我们还想做的一件事是编写一个脚本，用来控制和编程这个对话：提供一个键盘，提出一些问题，然后根据回答触发某些操作。当然，还要与 TON 进行交互，因为我们正在为区块链上的合约构建一个接口。

准备开始

我们在开始一个新项目时，先创建一个新目录并将其移动到该目录中：

1. mkdir first_contract_tg_bot
   - v( f) c& P7 I0 [% C/ p* t7 ]/ L7 k
2. cd first_contract_tg_bot

复制代码

现在我们设置一个新软件包：

1. yarn init
   

复制代码

是时候安装几个库了。我们将继续使用 TypeScript，所以首先要安装  typescript for node、types  for node 和 swc/core，后者可将 TypeScript 编译成 JavaScript：
  ]! }' {  I/ x5 O! z

1. yarn add typescript ts-node @types/node @swc/core --dev
   ( R2 C8 V4 [$ P+ f+ F0 A6 N

复制代码

我们需要在这里创建一个新文件，名为 tsconfig.json，内容如下：

- L; {9 o2 V) n' S2 t. n

1. {
   , v' v# W; L3 }) r9 c2 W# p$ ?
2.   "compilerOptions": {
   
3.     "target": "es2020",
   
4.     "module": "commonjs",
   6 B$ A+ V& D2 y0 j) N
5.     "esModuleInterop": true,
   
6.     "forceConsistentCasingInFileNames": true,
   
7.     "strict": true,
   
8.     "skipLibCheck": true,
   
9.     "resolve]sonModule": true
   5 h8 e0 T. q  [5 G
10.   },
    % x/ c! Q: f3 K0 S
11.   "ts-node": {
    
12.     "transpileOnly": true,
    
13.     "transpiler": "ts-node/transpilers/swc"
    
14.   }
    
15. }

复制代码

这里有 TypeScript 转译器的配置和编译器的标准配置。

这个项目是空的。我们需要安装一个新的 SDK，帮助我们与聊天机器人 API 交互。我建议使用名为 Telegraf 的 SDK：

1. yarn add telegraf
   9 f2 `) O; }* s& M

复制代码

在安装过程中，让我回到浏览器，给你看看它的一些文档 (https://telegrafjs.org/#/?id=example) 。它非常容易上手，当你想创建复杂的聊天机器人时，它也是一把好手。

机器人编程

我们已经安装了 Telegraf。现在，我们要在根目录下创建 src 文件夹，并在该文件夹下创建 index.tx 文件。然后，我们立即在 package.json 中创建一个脚本，并通过命令行运行我们的代码。

1. {
   
2.   "name": "first_contract_tg_bot"
   
3.   "version": "1.0.0",
     @% p8 i* l/ v
4.   "main": "index. js",
   2 X5 M) w$ L& U+ F2 }1 S% Q
5.   "license": "MIT"
   . X& a; ?# S: ~# m! z
6.   "devDependencies": {
   
7.     "@swc/core"; "^1.3.42",
   
8.     "@types/node": "^18.15.9",
   ' H; j' Y7 V' P/ g$ I
9.     "ts-node": "^10.9.1",
   4 _" _; M/ I( n* o% |! D  M
10.     "typescript": "^5.0.2"
    
11.   },
    : o- Q& ?$ g% t* v
12.   "dependencies": {
    
13.     "telegraf": "^4.12.2"
    7 k0 k* o; G# V& k) X- G( D
14.   },
      {) ~3 |( i- x$ Q) o6 K! Y  |
15.   "scripts": {
    
16.     "start": "ts-node ./src/index.ts"
    
17.   }
    
18. }

复制代码

脚本将使用 ts-node 来实际运行我们要编程的 index.ts。让我们来看看这里的示例。当然，这不是一个 TypeScript API 示例，但我们准备了一些代码 (https://telegrafjs.org/#/?id=example) 。首先，我们要以 TypeScript 的方式导入 Telegraf：
  S: W: A' X  k" [, z/ H9 Z2 m

1. import { Telegraf } from "telegraf";
   

复制代码

接下来，我们需要启动一个机器人实例。因此，我们要创建一个 Telegraf 实例：

( ?' F. T& v9 [. k( x: {3 [

1. const bot = new Telegraf(' ');
   

复制代码

它首先接受的是令牌。我们在使用 BotFather API 时已经看到过这个令牌。因此，我们需要返回，看看我们的令牌是什么并将其复制

1. const bot = new Telegraf("6015353320:AAF4LZh2hvZSRHQcZNDMyuePl41yd2ZAMyM");
   

复制代码

开发聊天机器人时，应该保留两个实例，一个用于测试，一个用于生产。因此，我们要用 env 变量将这些令牌分开。在 src 文件夹中，我们创建一个名为 .env  的新文件，以确保该文件从未提交到仓库中。我们将其命名为 TG_BOT_TOKEN，并以此启动 .env 文件：

1. TG_BOT_TOKEN=6015353320:AAF4LZh2hvZSRHQcZNDMyuePl41yd2ZAMyM
   $ F6 m5 j9 v/ M. U

复制代码

帮助我们与这些变量交互的库叫做 dotenv，让我们添加它：

/ g. ~# s2 z4 N! y& v

1. yarn add dotenv
     J6 h2 }2 \/ ?' s, F, u

复制代码

安装后，我们可以从 index.ts 中访问它：

1. const bot = new Telegraf(process.env.TG_BOT_TOKEN!);
   

复制代码

但首先我们需要配置并导入 dotenv。因此，让我们在文件的开头进行配置：

+ `' d$ ^. [! V- I' e% G+ h( t

1. import dotenv from "dotenv"
   : K# d' a! t$ y' e% L9 P

复制代码

重要的是尽快在项目中运行 dotenv.config 函数，因此我们在导入后添加

* G' g# a% M* Y5 T( y3 l6 J- C

1. dotenv.config();
   

复制代码

这个变量可能是未定义的，但我们知道它实际上是在 .env 中定义的。因此，我们可以说它肯定会存在。如果它不存在，就会失败，因此不会启动 Telegraf 实例。

酷，让我们看看一步步开始机器人交互后的示例代码是怎样的：

1. bot.start((ctx) =>
   
2.   ctx. reply ("Welcome to our counter app!", {
   9 d' a# K( @5 n- U9 A. U1 ?
3.     reply_markup: {
   
4.       keyboard: [
   ' S! W: L- g7 M6 U& d- O, x7 g
5.         ["Increment by 5"],
   
6.         ["Deposit 1 TON"],
   
7.         ["Withdraw 0.7 TON"],
   ) Y7 E; T% }; C! x- j
8.       ],
   
9.     },
   # ]( M/ w6 @5 t5 w% u1 x' O3 s! ?
10.   })
    2 D( n$ U; s! o; ^/ P+ ~
11. );

复制代码

这个 Telegraf 机器人实例为我们提供了一个启动方法。当你第一次进入聊天机器人时，它就会被触发：你应该记得，当我们刚刚打开聊天机器人时，我们点击了 start。一旦你运行了第一条信息，你就会回复一条欢迎信息，并附加一个键盘。

我们来看看这个键盘会是什么样子。Telegram 聊天机器人可以让你创建自己的键盘，取代你输入信息时看到的原始键盘。你还可以在消息下方创建内嵌键盘。我们稍后再谈；现在我们只使用一个简单的键盘。

在这里，我们将创建三行和三个按钮。在网络上，"请求 "交易（如 "请求存款"）是合适的，因为您授权应用程序向您提出请求。但在这里，我们有直接的交易链接，您与聊天机器人本身没有会话，所以按钮中的动作动词更合适，比如 "存款"。当然，您也可以在后台保留会话，但这样做不妥，因为会造成安全漏洞。

1. bot.hears("Increment by 5", (ctx) => {
   6 Y* [. U' B+ k) g- F
2.   // TODO: send increment transaction
   ( T+ R7 t, G) A4 P
3.   ctx ,reply("Incremented by 5");
   + p. C9 P5 f; [
4. });
   " |" j' ]* ~* f1 K1 ^
5. bot.hears("Deposit 1 TON", (ctx) => {
   
6.   // TODO: send deposit transaction
   
7.   ctx ,reply("Deposited 1 TON");
   - l" `; {5 B7 }$ Z) P+ D7 w
8. });
   / L9 v! l1 \& N! Q
9. 
   
10. bot.hears ("Withdraw 0.7 TON", (ctx) =>
    1 v9 X4 e  I# K! C6 {0 r1 r- K
11.   // TODO: send withdraw transaction
    ; v" J3 L8 S  d9 T+ o1 s- f; }
12.   ctx ,reply("Withdrawn 0.7 TON");
    " n% D- s' K6 R! ~7 |
13. });

复制代码

在这里，我们有几个功能。bot.hears 表示机器人会收到这样的信息。我们可以发送回复 "增加 5"。然后，我们还可以添加类似的回复。

最后，我们添加一个函数来启动机器人，并添加几行代码来确保机器人正确退出：

1. bot.launch();
   2 e( Y9 y7 F3 y, z1 }9 Q. Z+ V$ x
2. 
   
3. // Enable graceful stop
   2 z8 `) \% r4 T: I1 q
4. process.once("SIGINT", () => bot.stop("SIGINT"));
   
5. process.once("SIGTERM", () => bot.stop ("SIGTERM"));

复制代码

好了，我们都准备好了，开始吧：

1. yarn start
   2 m+ E. _# ?1 d3 f! _8 b4 a

复制代码

我们的机器人已经开始工作，但重要的是要在应用程序中进行检查。打开机器人，再次点击 "开始"：

( H( `5 W$ v, V5 b# ]8 F5 z

正如您所看到的，我们有三个带有文本的按钮。点击其中任何一个按钮后，我们就会得到想要的回复。如果点击 "计数器"，我们的应用程序将以网络应用程序的形式打开。那么，我们该如何让菜单操作发挥作用呢？

5 T# M* _/ q( ]8 _- d使菜单操作有效
我们正在创建一个部署脚本。大家还记得吧，我们创建了一个链接，可以扫描二维码直接进入钱包，在钱包中签署交易来部署合约。现在我们也可以做同样的事情。一旦你的用户获得了选项，比如以 5 为单位递增，你就可以创建一个链接，让他直接进入 Tonhub 进行支付。
2 W1 w3 {( k  T+ i9 Q8 x( \

首先，让我们安装使用 TON 所需的库：

) c8 M% W0 f  ^5 D# B: c  T

1. yarn add ton-core ton-crypto
   

复制代码

我们需要 ton-core 和 ton-crypto 来编写信息。要建立链接，我们需要这些库：

1. yarn add qs @types/qs --dev
   9 G& B  X! ]1 T$ B1 \

复制代码

现在，我们将重复使用第一课中的一些代码。确保我们的合约地址是正确的。你还记得，在 first_contract_front_end 项目中，我们创建了一个挂钩，该挂钩附加到某个合约。让我们从 useMainContract.ts 中获取地址：

1. const mainContract = useAsyncInitialize(async () => {
   
2. 
   
3.   if (!client) return;
   % P% l. T- u0 b# Z/ i
4. 
   4 v' n* ~" D5 A7 m% O5 N6 ?
5.   const contract = new MainContract(
   3 E3 a; I+ V& e
6. 
   0 E  S, H; b0 v9 Y
7.     Address.parse("EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq") // replace with your address from tutorial 2 step 8
   * a6 D8 O( W  V& p
8. 
   
9.   );
   
10. 
    0 v9 P+ V8 o' {' D% n
11.   return client.open(contract) as OpenedContract<MainContract>;
    
12. 
    # F) @! Y* s. b; e0 a6 `" e
13. }, [client]);

复制代码

现在，我们需要导入地址结构。

1. bot. hears ("Increment by 5", (ctx) => {
   . l# H0 u* U5 ^) ^1 u
2.   let link =
   
3.     `https://test.tonhub.com/transfer/` +
   2 M0 ^5 Q: l* @: U2 q7 x( X+ o
4.   Address.parse ("EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq").toString
   : G9 M7 I1 \7 a2 x: _$ d
5.     RestOnly: true,

复制代码

我们不会在主网中做任何事情，这只是测试网。我们从特定地址中解析出地址类，然后将其转换为字符串。实际上，我们可以直接这样做，因为我们显然需要一个字符串。然后，让我们重新组合，使代码更简洁：

1. bot. hears ("Increment by 5", (ctx) => {
   9 x( h( G, n6 f9 U* m
2.   let link = `https://test.tonhub.com/transfer/EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq?${qs.stringify(
   
3.     {
   1 Y% e1 m+ ]8 v3 t0 a
4.       text: "Simple test transaction",
   1 V- f* `' k9 r7 n
5.       amount: toNano ("0.05") . toString (10) ,
   
6.       bin: msg body toBoc({ idx: false }). toString ("base64"),
   % Z& T% U* C0 p  b) l, }3 R
7.     }
   
8. )}`;

复制代码

我们甚至可以这样做：

1. ​​const SC_ADDRESS = "EQBDUxTxWo41aCY1SGZJJ1Dnu4uKvZtb0juGF9mtf22M1UBq";
   & H3 S5 u8 v9 C7 |3 d& J

复制代码

因此，我们把智能合约地址放到链接中：

1. bot.hears ("Increment by 5", (ctx) => {
   
2.   let link = `https://test.tonhub.com/transfer/${SC_ADDRESS}?$ {qs.stringify(
   
3.     {
   
4.       text: "Simple test transaction",
   7 B6 V- ~+ F; ~1 K5 B' c! q) w) W
5.       amount: toNano ("0.05") . toString (10) ,
   ! i# ?  A2 a# J- Y0 v
6.       bin: msg ,body ,toBoc({ idx: false }). toString ("base64"),
   
7.     }
   & |; R2 p: \+ X6 Z; {: m$ D) M- N
8. )}`;

复制代码

你甚至可以再做一项改进。就像我们为令牌设置环境变量一样，我们也可以在 .env 中设置智能合约地址来执行此操作，因为在生产过程中，你很可能也会在主网上设置一个合约：
3 E3 ~0 F! s# g2 {& D( Z# E0 a

1. SC_ADDRESS=EQBDUxTxWo41aCY1SGZJJ1Dnu4uKvZtb0juGF9mtf22M1UBq
   

复制代码

现在在 index.ts 中，我们不再需要地址对象了。

1. import { Address } from "ton-core";
   

复制代码

在 bot.hears 的 Amount 中，我们从上下文菜单中选择 Add import from "ton-core" ，并在链接中添加  process.env：

7 C/ @' |  Z+ Z: j7 L6 o

1. bot.hears ("Increment by 5", (ctx) => {
   9 u; f' p2 S9 ]; b/ E3 L* |1 K
2.   let link = `https://test.tonhub.com/transfer/${process.env.SC_ADDRESS}?$ {qs.stringify(
   
3.     {
   % \/ W+ J- W" s" x
4.       text: "Simple test transaction",
   9 z; O, z9 l& h) J$ o. b7 z: _0 X
5.       amount: toNano("0.05").toString(10),
   7 N; t. H( p4 X) u. c
6.       bin: msg_body.toBoc(( idx: false )). toString("base64"),
   0 z* s! _' U' L6 B
7.     }
   
8. )}`;

复制代码

在这里，我们需要形成一个信息正文。什么是信息正文？我们使用 "生成器"，因为我们要把消息正文作为Cell，然后由 TON 将其转换为字符串表示法。我们要在消息正文中输入什么内容呢？

我们正在创建合约及其封装。我们将发送一个增量函数。为此，我们可以直接从 wrappers > MainContract.ts:

1. const msg ,body = beginCell()
   
2.   .storeUint(1, 32) // OP code
   
3.   .storeUint(increment_by, 32) // increment_by value
   
4.   .endCell();

复制代码

它显示了我们要递增的整数和递增多少的整数。所有这些我都会复制到我的机器人项目中：

1. bot.hears("Increment by 5", (ctx) => {
   6 U7 A& I: F8 n! Z
2. 
   
3. const msg_body = beginCell()
   6 }" |  M  y3 Q! |: M- @
4.     .storeUint(1, 32)
   0 i9 y4 M, a7 s3 y* w' o! e& o
5.     .storeUint(5, 32)
   6 z) J7 A- {  \
6.     .endCell();
   
7. 
   0 m: x$ x! n+ p! Y
8. let link = `https://app.tonkeeper.com/transfer/${process.env.SC_ADDRESS
   
9. }?${qs.stringify(
   
10.     {
    
11.       text: "Simple test transaction",
    " l* ?# q6 B0 X6 E$ H: Y5 U/ d
12.       amount: toNano("0.05").toString(10),
    & y2 ?" e8 r2 u. o8 d3 f# m: m; b
13.       bin: msg ,body.toBoc({ idx: false }).toString("base64"),
    , d$ Z) R# v4 q5 n
14.     }
    
15. )}`;

复制代码

我们不要求增量，但我们知道它是 5，所以我们把 5 放在这里。你可以随意调整，要求增量。在我们的例子中，我们已经有了5个硬编码了。现在我们在开始时导入 qs：

1. import qs from "qs";
   

复制代码

很好，我们导入了所有内容，现在来对对象进行字符串化。我们说要将计数器递增 5 - 这只是附加到消息中的一个文本。然后把 0.05 作为实际支付交易费用的金额。然后我们使用这个参数费。

在此，我们前往 Tonhub 开发人员文档。我们使用的链接仅适用于 Tonhub，但你也可以使用 Tonkeeper 链接。在文档中，你也可以找出 URL 的结构来提供一些值。

Bin parameter everywhere 用于传递 msg_body，一旦您想发送带有特定参数的消息。这正是我们在这里要做的事情：我们为 Tonhub 创建了一个付款链接。

但在此之前，我们需要让机器人回复用户。一位用户使用我们在开始时提供的键盘给我们发送了 "递增 5 "的消息。我们需要回复，让用户知道他能做什么。我们需要提供一个链接。我们可以简单地发送链接，但我们希望它对用户非常友好。这就是为什么我们要回复一条信息：

1. ctx.reply("To increment counter by 5, please sign a transaction:", {
   
2.     reply_markup: {
   , o' i9 d  ]! a: T, s
3.         inline_keyboard: [
   
4.             [{
   
5.                 text: "Sign transaction",
   
6.                 url: link,
   
7.             }]
   
8.         ]
   
9.     }
   
10. })

复制代码

然后，我们创建一个额外的参数。回复标记可以是 InlineKeyboard, ReplyKeyboard, ReplyKeyboardRemove 或 ForceReply。这里有多个选项，我们希望使用 inline_keyboard。

上次我们使用的是普通键盘，位于输入行下的同一位置。现在我们创建了一个内联键盘，如上图所示。它有几个参数：文本、签名交易和 URL。因此，我们在 bot.hears 中提供了一个带有链接的 URL 参数。

有一件事我之前没有提到，但你应该记住：如果我们想把某个Cell作为链接发送，比方说，连同一些字符串或链接一起发送，我们需要把它打包成 base64，就像信息正文的Cell一样。

好吧，看来这个办法行得通：

1. yarn start
   6 ^, |, p+ C. R* \

复制代码

一切正常，于是我回到手机上。我打开开始命令提供的键盘，点击 "递增 5"：

如您所见，我们收到了一条信息，要求我们签署一项交易，以 5 为增量。交易已发送。如何检查交易是否真的影响了我们的合约状态？如果检查网络应用程序，可以看到 "计数器值 "等于 15，而之前是 10。
1 J3 ~& k- y1 d" u" W
进一步改进机器人

我们可以通过聊天机器人构建特定的用户流，用户将在后端与我们的区块链进行交互。我们在后端没有任何用户凭证，所以我们实际上是在为他提供钱包链接，让他进行支付。我希望这不会让你感到困惑，因为作为开发者，你应该始终考虑可用性。而这正是可以显著提高可用性的方法之一。

Telegram 中的网络应用程序可让您使用自动消息创建有趣、酷炫的聊天对话。这样，您就能为用户创建极具价值的精彩项目。让我们构建一个类似的链接：

1. bot.hears("Deposit 1 TON", (ctx) => {
   
2.   const msg_body = beginCell().storeUint(2, 32).endCell();

复制代码

我们将用 2 来表示存款数额。我们不需要其他任何东西，让我们在 wrappers > MainContract.ts 中再次确认这一点：

; h! h2 p% t0 u

1. async sendDeposit(provider: ContractProvider, sender: Sender, value: bigint) {
   
2.   const msg_body = beginCell()
   
3.     .storeUint(2, 32) // OP code
   + M( Q0 R2 K6 V8 P5 h
4.     .endCell()

复制代码

接下来，我们需要输入存款命令，否则我们将无法在合约上收钱。在 index.ts 中，我们只需输入一个等于 2 的整数（32 位）。在这里，我们说它将是 "Deposit 1 TON"（存款 1 Ton），实际上我们将要求提供 1 Ton的付款。它不必是一个字符串。

// Final code deposit command

1. bot.hears("Deposit 1 TON", (ctx) => {
   % F+ c  j% X! _8 Y0 \
2.     const msg_body = beginCell().storeUint(2, 32).endCell();
   
3. 
   3 [3 [4 g* D- |* L3 u
4.       
   $ p, r/ c  L9 q4 H1 M
5.     let link = `https://app.tonkeeper.com/transfer/${
   
6.         process.env.SC_ADDRESS
   
7.     }?${qs.stringify(
   : \* ?* }, t/ y) p- ~2 k
8.         {
   
9.             text: "Deposit 1 TON",
   
10.             amount: toNano("1").toString(10),
    
11.             bin: msg_body.toBoc({ idx: false}).toString("base64"),
    
12.         }
    , l8 n0 z+ I/ c1 U* o* L& X
13.     )}`;

复制代码

因此，我们要求用户向合约发送 1 Ton，并在信息中注明这是存款。我们在这里输入信息，然后删除回复 "已存入 1 Ton"，因为我们不再需要它了：
) N& W3 M( O; @

1. ctx.reply("To deposit 1 TON please sign a transaction:", {
   
2.   reply_markup: {
   1 P0 g) {4 d# ?- y
3.     inline_keyboard: [
   
4.       [
   
5.         {
   ) V4 y5 L! Q8 @/ i: y: a% W
6.           text: "Sign transaction",
   4 B* m* a* d! H! Z
7.           url: link,
   : h( U# ?! E# @
8.         }
   
9.       ]
   
10.     ]
    ; w7 `; F2 ^5 z3 s
11.   }
    
12. });

复制代码

所以这很简单。我们形成一个消息正文、一个链接、链接文本，将 1 Ton金额设为存款，将正文放入一个字符串，然后用链接中的键盘回复。我们还需要做的一件事就是将机器人的存款逻辑复制到取款逻辑中：

// Final code withdraw command

1. bot.hears("Withdraw 0.7 TON", (ctx) => {
   
2. const msg_body = beginCell().storeUint(3, 32).endCell();
   
3.   
   
4. let link = `https://app.tonkeeper.com/transfer/${
   
5.     process.env.SC_ADDRESS
   
6. }?${qs.stringify(
   
7.     {
   
8.         text: "Deposit 1 TON",
   
9.         amount: toNano("1").toString(10),
   
10.         bin: msg_body.toBoc({ idx: false}).toString("base64"),
    ( N+ m! N9 Y; ]1 _3 o
11.         }
    
12. )}`;
    - D" g+ H4 T2 h) g& {
13.    
    / h5 l% d; \, y4 F0 I3 W
14. ctx.reply("To deposit 1 TON please sign a transaction:", {
      i* F, B; z7 D" l3 k, U2 l
15.   reply_markup: {
    
16.     inline_keyboard: [
    $ C: ~, [. W9 J% B
17.       [
    9 U1 u6 r( Z9 Y0 p* Q4 L: `  G2 E5 |) ~
18.         {
    ( W+ X- h* g6 _) G8 p
19.           text: "Sign transaction",
    4 q: o$ Y4 c# A; Q! a, T
20.           url: link,
    
21.         }
    
22.       ]
    
23.     ]
    
24.   }
    ( r1 \! Q3 f0 ~2 }: K6 F+ R& b
25. });

复制代码

现在我们回到提款的包装。在 index.ts 中，我们需要提供想要提取的金额：

1. bot.hears("Withdraw 0.7 TON", (ctx) => {
   0 F# e' J1 k. h6 ~' T
2. const msg_body = beginCell().storeUint(3, 32).storeCoins(toNano(`0.7`))endCell();

复制代码

我们添加了关于提取 0.7 TON的文字，接下来我们把足够支付GAS费Ton数放进去，因为我们要在这里拿钱：

1. let link = https://test.tonhub.com/transfer/${
   
2.   process.env.SC_ADDRESS
   & v. |/ A& a  u! n; u: l- F
3. }?${as.stringify({
   - F) H/ E0 L/ ~+ R# \
4.   text: "Withdraw 0.7 TON",
   ! L' N- O& L0 e6 U. H# l
5.   amount: toNano('0.05').toString (10),
   8 F' l7 \$ E+ \
6.   bin: msg_body.toBoc({ idx: false }).toString("base64"),
   * Q/ D# B" ?+ F6 _3 z  |
7. })}`;

复制代码

然后编辑机器人信息：

1. ctx.reply("To withdraw 0.7 TON please sign a transaction:", {
   
2.     reply_markup: {
   
3.         inline_keyboard: [
   8 x5 ^* ]. U5 T$ U$ o; K
4.             [{
   4 d; C. ?$ C7 Y# f/ C9 x
5.                 text: "Sign transaction",
   
6.                 url: link,
   
7.             }]
   $ }$ f. k8 F$ d, W
8.         ]
   3 j7 V$ A5 {0 p8 H2 @
9.     }
   $ Z0 l8 c* M! {# @
10. });

复制代码

我们用 yarn start 重启机器人，回到 Telegram 应用程序。现在，我们不仅可以存款，还可以以同样的方式取款：

现在，我们访问 Telegram 中的网络应用程序文档，阅读更多有关该 SDK 中可用内容的信息 (https://core.telegram.org/bots/webapps) 。这里有 initData 和 initDataUnsafe。当我们想在启动网络应用时发送一些原始数据时，就会用到它们。通过这个版本，我们可以检查用户 Telegram 应用程序中可用的机器人 API 版本。通过这个平台，我们可以检测平台。我们还可以调整配色方案和主题参数--这些选项由 Telegram 文档提供。我们可以检查是否已展开，并设置窗口高度。

我们现在需要的是 sendData（发送数据）--一种向机器人发送数据的方法。调用该命令后，带有数据的服务消息就会发送给支持的机器人，其中包含给定长度的数据。重要的是，运行该命令后，会有一条消息发送到你的 Telegram。基本上，一旦你运行了 sendData 函数，你发送的信息就会由我们刚刚创建的后端机器人处理。你的处理方式会是这样的：

1. bot.on(message("web_app_data"), (ctx) => ctx.reply("ok"));
   

复制代码

您还需要从 telegraf/filters:

! z6 Q$ j  `  z# P+ g

1. import { message } from "telegraf/filters";
   1 F6 s+ M& y. C2 {6 ^

复制代码

您可以在这里发送贴纸或消息，但要过滤网络应用程序的数据。在这里，您将收到从网络应用程序发送的数据。需要注意的是，这是用于关闭的，因此一旦运行 sendData 方法，网络应用程序就会关闭。

4 H# n$ ~( h  \: o3 C结论

差不多就是这样。我们今天学到了很多东西。实际上，我们已经知道了如何使用一种最好的方式将应用程序推向大众。TON 涉及大规模应用，因此你必须掌握如何构建应用程序，以便将其整合到载体中。如果 Telegram 是这么多人的载体，TON 是我们非常喜爱的区块链，而且这个平台已经为这么多人做好了准备，那么你们为什么不构建自己的应用程序，并将可扩展技术带入已经有这么多用户在等待你们产品的地方呢？

6 l  ^$ j5 S* J

我很高兴你们现在已经具备了这样的条件。我希望你已经明白了一切，希望你所学到的一切都能帮助你打造自己的产品。下一章再见。谢谢！

6 m3 v3 k* `% ^  S) F

6 d! _& {; H9 a3 c
5 m1 {; I: B' ]2 {" g

! l- k8 @. g8 V
) `3 r/ e& H. D7 Q; L5 t- s. i

1 r' X9 |* k3 o$ i8 s

0 E$ W/ U4 P' R& ]( _7 N' e

# X* C$ H: g/ K6 x5 N: _. T



- C5 z* {" I: t# Z" C# T: T
3 m: y; j' u) ]9 g! v8 X+ i% j