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

riyad

) Q9 t0 T* w4 b1 Q/ _# m
; u" f/ @( p4 W! I2 b2 y' s& V

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

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

# V9 P5 H) v6 B. Y" ?

准备开始

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

1. mkdir first_contract_tg_bot
   ! y5 m% a0 u- P! o# r
2. cd first_contract_tg_bot

复制代码

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

% v: Y; z% V& l, ~8 G

1. yarn init
   5 S4 P/ n6 M5 l/ w: C% C

复制代码

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

1. yarn add typescript ts-node @types/node @swc/core --dev
   6 l/ G! C7 h; H* U, [

复制代码

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

) M; P) B, s" Z4 h& S

1. {
   
2.   "compilerOptions": {
   
3.     "target": "es2020",
     n. q9 V1 v4 q2 ~, q
4.     "module": "commonjs",
   1 V0 Q9 s+ V7 A  E! Y& D+ T' P, y# }0 l
5.     "esModuleInterop": true,
   
6.     "forceConsistentCasingInFileNames": true,
   
7.     "strict": true,
   ( `; L$ ~2 ^! W: J7 G' ~# b
8.     "skipLibCheck": true,
   
9.     "resolve]sonModule": true
   
10.   },
    
11.   "ts-node": {
    
12.     "transpileOnly": true,
    
13.     "transpiler": "ts-node/transpilers/swc"
    
14.   }
    ' {0 K. y0 B  J( i( W
15. }

复制代码

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

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

1. yarn add telegraf
   ! I) y8 T% K" `

复制代码

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

) K# u% Y* u+ R) v% o- y

机器人编程

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

1. {
   
2.   "name": "first_contract_tg_bot"
   
3.   "version": "1.0.0",
   
4.   "main": "index. js",
   
5.   "license": "MIT"
   - X2 [4 H7 Q  d3 r' J% U) }
6.   "devDependencies": {
   & H) c8 h/ W! N* H$ Y( @
7.     "@swc/core"; "^1.3.42",
   ; ]0 z( ?% C! I0 S& `3 w0 P
8.     "@types/node": "^18.15.9",
   
9.     "ts-node": "^10.9.1",
   
10.     "typescript": "^5.0.2"
    
11.   },
    
12.   "dependencies": {
    
13.     "telegraf": "^4.12.2"
    % S: t% U) \9 w4 y
14.   },
    , c+ F# X* }1 {( A  H1 }' k
15.   "scripts": {
    
16.     "start": "ts-node ./src/index.ts"
    
17.   }
    
18. }

复制代码

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

1. import { Telegraf } from "telegraf";
   

复制代码

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

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

复制代码

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

1. const bot = new Telegraf("6015353320:AAF4LZh2hvZSRHQcZNDMyuePl41yd2ZAMyM");
   4 V2 w& ~  z( w' }% Q. m$ x9 l" J

复制代码

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

1. TG_BOT_TOKEN=6015353320:AAF4LZh2hvZSRHQcZNDMyuePl41yd2ZAMyM
   

复制代码

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

1. yarn add dotenv
   8 i: d/ i- H. A7 T; E+ }- A# k: K4 q

复制代码

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

1. const bot = new Telegraf(process.env.TG_BOT_TOKEN!);
   * d) p) V' g2 S. e* \# _6 q9 Q

复制代码

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

! p& W9 C% \% o0 f2 t8 c

1. import dotenv from "dotenv"
   # x, ], V: g: w- J6 V( g  ~

复制代码

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

" {. G  q% L7 `. Z9 ^

1. dotenv.config();
   

复制代码

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

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

1. bot.start((ctx) =>
   
2.   ctx. reply ("Welcome to our counter app!", {
   
3.     reply_markup: {
   % q- C4 j% _5 j2 u
4.       keyboard: [
   1 G/ w% l4 _' [5 C5 x, T. L) t3 l
5.         ["Increment by 5"],
   
6.         ["Deposit 1 TON"],
   & ^1 p; Y7 q0 F3 V
7.         ["Withdraw 0.7 TON"],
   
8.       ],
   
9.     },
   $ h& Z% w' ?0 W9 ^5 L
10.   })
    1 U8 [) Z) i9 V5 w7 u2 N8 h" C: D
11. );

复制代码

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

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

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

1. bot.hears("Increment by 5", (ctx) => {
   
2.   // TODO: send increment transaction
   
3.   ctx ,reply("Incremented by 5");
   
4. });
   / I( N3 p- A( x
5. bot.hears("Deposit 1 TON", (ctx) => {
   
6.   // TODO: send deposit transaction
   
7.   ctx ,reply("Deposited 1 TON");
   
8. });
   
9. 
   , Y6 r  `6 C6 u$ g( V  `
10. bot.hears ("Withdraw 0.7 TON", (ctx) =>
    
11.   // TODO: send withdraw transaction
    7 k8 p8 z. i" l  M
12.   ctx ,reply("Withdrawn 0.7 TON");
    , ~$ D! F& h( v3 _: m+ Z- U
13. });

复制代码

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

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

1. bot.launch();
   6 k. h' _* k/ H! \7 K5 Y
2. 
   
3. // Enable graceful stop
   
4. process.once("SIGINT", () => bot.stop("SIGINT"));
   ; h* c1 u% I4 y
5. process.once("SIGTERM", () => bot.stop ("SIGTERM"));

复制代码

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

) k, ^6 u& P, G% T% Z

1. yarn start
   5 x0 T0 M1 v- r

复制代码

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

: u8 \1 R! R$ D& [1 B8 w
# F1 ~+ @1 a0 |1 p, J% ^7 c4 f# n, t

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

使菜单操作有效
我们正在创建一个部署脚本。大家还记得吧，我们创建了一个链接，可以扫描二维码直接进入钱包，在钱包中签署交易来部署合约。现在我们也可以做同样的事情。一旦你的用户获得了选项，比如以 5 为单位递增，你就可以创建一个链接，让他直接进入 Tonhub 进行支付。
" y; l9 ]* M* D* v5 r

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

1. yarn add ton-core ton-crypto
   

复制代码

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

1. yarn add qs @types/qs --dev
   

复制代码

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

6 I$ J, e8 V  T; u; B

1. const mainContract = useAsyncInitialize(async () => {
   
2. 
   + P8 @6 D4 Q  Q( Z' ^5 ]8 l( Z" @
3.   if (!client) return;
   8 U/ q6 t; {3 C. M' F
4. 
   
5.   const contract = new MainContract(
   , c$ c% l% }; O$ z8 W5 v/ k$ r9 i
6. 
   8 X8 L' n- q" y, F  N% o
7.     Address.parse("EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq") // replace with your address from tutorial 2 step 8
   & |7 B0 J8 ^" O& q
8. 
   
9.   );
   
10. 
    
11.   return client.open(contract) as OpenedContract<MainContract>;
    
12. 
    2 v. P* F# a6 x2 f+ {4 i  B/ q
13. }, [client]);

复制代码

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

1. bot. hears ("Increment by 5", (ctx) => {
   
2.   let link =
   9 E7 p& ^. W/ _& f# |/ o
3.     `https://test.tonhub.com/transfer/` +
   
4.   Address.parse ("EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq").toString
   ( e* A1 l2 F6 h) D4 \% X
5.     RestOnly: true,

复制代码

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

1. bot. hears ("Increment by 5", (ctx) => {
   * Q& C, }$ S0 d8 A; d1 H  j5 i
2.   let link = `https://test.tonhub.com/transfer/EQBDUxTxWo41aCY1SGZJJlDnu4uKvZtbOjuGF9mtf22M1UBq?${qs.stringify(
   
3.     {
   
4.       text: "Simple test transaction",
   / B8 o5 z$ U) B; N
5.       amount: toNano ("0.05") . toString (10) ,
   
6.       bin: msg body toBoc({ idx: false }). toString ("base64"),
   : R* I$ A9 `6 r
7.     }
   ' y9 s1 K* T2 h
8. )}`;

复制代码

我们甚至可以这样做：

1. ​​const SC_ADDRESS = "EQBDUxTxWo41aCY1SGZJJ1Dnu4uKvZtb0juGF9mtf22M1UBq";
   

复制代码

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

1. bot.hears ("Increment by 5", (ctx) => {
   4 ^4 a& V( h9 J8 L# e4 a
2.   let link = `https://test.tonhub.com/transfer/${SC_ADDRESS}?$ {qs.stringify(
   - l, |1 M4 l+ C0 L: M$ T: D' g
3.     {
   3 }4 |2 P/ a5 Q$ _* `
4.       text: "Simple test transaction",
   6 U. I( {, E8 b7 J. ]$ i: y, s0 Z7 a
5.       amount: toNano ("0.05") . toString (10) ,
   
6.       bin: msg ,body ,toBoc({ idx: false }). toString ("base64"),
   
7.     }
   ! T- U" e" a. B; G- E& U
8. )}`;

复制代码

你甚至可以再做一项改进。就像我们为令牌设置环境变量一样，我们也可以在 .env 中设置智能合约地址来执行此操作，因为在生产过程中，你很可能也会在主网上设置一个合约：
3 _* u% U0 N& U% D: a# _( g

1. SC_ADDRESS=EQBDUxTxWo41aCY1SGZJJ1Dnu4uKvZtb0juGF9mtf22M1UBq
   : E& u. K8 T% k( v

复制代码

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

! t! y* i  z" |) L% `

1. import { Address } from "ton-core";
   1 L+ Q, W! ]! }, v

复制代码

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

* t# X4 y: t4 x/ R3 M

1. bot.hears ("Increment by 5", (ctx) => {
   7 s: i+ R3 B8 e% d! i+ q% B
2.   let link = `https://test.tonhub.com/transfer/${process.env.SC_ADDRESS}?$ {qs.stringify(
   
3.     {
   / Y9 ~% P7 K6 X
4.       text: "Simple test transaction",
     [( y" G7 S; \1 Q, L
5.       amount: toNano("0.05").toString(10),
   / D) x. ]1 l) V1 U$ i: H
6.       bin: msg_body.toBoc(( idx: false )). toString("base64"),
   
7.     }
   
8. )}`;

复制代码

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

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

1. const msg ,body = beginCell()
   
2.   .storeUint(1, 32) // OP code
   / q" x# ~9 P2 P8 C
3.   .storeUint(increment_by, 32) // increment_by value
   
4.   .endCell();

复制代码

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

1. bot.hears("Increment by 5", (ctx) => {
   3 I0 A7 C/ @+ e: Z
2. 
   / v# ^3 O3 m1 h
3. const msg_body = beginCell()
   0 d$ V9 L" E" p7 Y- v- K
4.     .storeUint(1, 32)
   & K4 ]8 d( H7 x  T
5.     .storeUint(5, 32)
   
6.     .endCell();
   ! _4 @9 p2 W) X9 o
7. 
   ' b$ p: J5 J7 z; x
8. let link = `https://app.tonkeeper.com/transfer/${process.env.SC_ADDRESS
   ' T' m. j' U5 x3 \- O2 ], Z$ `, ^- ^
9. }?${qs.stringify(
   + f( Y) w" Y  n! k/ }4 G6 E
10.     {
    5 y: T2 |2 n0 y3 _. P  i, E3 _
11.       text: "Simple test transaction",
    
12.       amount: toNano("0.05").toString(10),
    
13.       bin: msg ,body.toBoc({ idx: false }).toString("base64"),
    % N7 Z7 T1 X( {* ]+ \; S
14.     }
    
15. )}`;

复制代码

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

1. import qs from "qs";
   - P' q# V7 k+ J& H8 N

复制代码

很好，我们导入了所有内容，现在来对对象进行字符串化。我们说要将计数器递增 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:", {
   4 y1 l7 A; n8 N; L7 o" V" w/ Q
2.     reply_markup: {
   
3.         inline_keyboard: [
   
4.             [{
   / M. S7 a1 M' Q! y
5.                 text: "Sign transaction",
   
6.                 url: link,
   % n" l9 w# F1 R& M5 E
7.             }]
   
8.         ]
   
9.     }
   
10. })

复制代码

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

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

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

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

1. yarn start
   

复制代码

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

如您所见，我们收到了一条信息，要求我们签署一项交易，以 5 为增量。交易已发送。如何检查交易是否真的影响了我们的合约状态？如果检查网络应用程序，可以看到 "计数器值 "等于 15，而之前是 10。
( O/ I) v5 D& Q3 ]6 F' l0 J4 c/ n0 q
进一步改进机器人

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

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

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

复制代码

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

1. async sendDeposit(provider: ContractProvider, sender: Sender, value: bigint) {
   
2.   const msg_body = beginCell()
   
3.     .storeUint(2, 32) // OP code
   
4.     .endCell()

复制代码

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

// Final code deposit command

1. bot.hears("Deposit 1 TON", (ctx) => {
   
2.     const msg_body = beginCell().storeUint(2, 32).endCell();
   
3. 
   " |. H! K8 y3 _# x& k4 y
4.       
   6 ?, Y$ H7 D$ _, B
5.     let link = `https://app.tonkeeper.com/transfer/${
   : p# X0 R. h6 {8 i8 R# _" l
6.         process.env.SC_ADDRESS
   # ~% P' s+ C* a
7.     }?${qs.stringify(
   7 n6 R+ O" Y4 j1 A( A
8.         {
   
9.             text: "Deposit 1 TON",
   : C1 v9 x* U2 ~4 E1 H( v+ V' I
10.             amount: toNano("1").toString(10),
    
11.             bin: msg_body.toBoc({ idx: false}).toString("base64"),
    ) D8 R% ^! D, A0 p
12.         }
    , D1 r4 q1 G# [8 V  K
13.     )}`;

复制代码

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

1. ctx.reply("To deposit 1 TON please sign a transaction:", {
   5 ?: r; {# l6 Z* o
2.   reply_markup: {
   
3.     inline_keyboard: [
   
4.       [
   
5.         {
   4 C' }! {/ e3 d' `8 e1 R3 ~
6.           text: "Sign transaction",
   + @$ V* J1 I2 D5 M1 |* g4 H; W
7.           url: link,
   ( h$ V: n& M! M: g  d( z' m
8.         }
   % j) Y$ a9 `/ v. S$ z
9.       ]
   
10.     ]
    2 i& B. L8 g+ r/ v' F8 T
11.   }
    3 M# F  |% c+ f) L5 o: G6 N
12. });

复制代码

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

// Final code withdraw command

1. bot.hears("Withdraw 0.7 TON", (ctx) => {
   9 E, ]; e; t( l/ v, U5 n( n  Y2 T
2. const msg_body = beginCell().storeUint(3, 32).endCell();
   4 O0 h& _+ P5 y9 a# i* Y$ ^
3.   
   & |' u1 S3 g" |. E4 M
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"),
    5 r5 y0 h) U& O+ K7 I' f
11.         }
    
12. )}`;
    
13.    
    
14. ctx.reply("To deposit 1 TON please sign a transaction:", {
    
15.   reply_markup: {
    
16.     inline_keyboard: [
    
17.       [
    
18.         {
    / t3 y- e- ^: A: ]
19.           text: "Sign transaction",
    
20.           url: link,
    - Z' `' {$ Z) H$ h: F
21.         }
    
22.       ]
    
23.     ]
    " K6 m- t+ f: C
24.   }
    & e& q/ }2 H1 ^1 ]7 C
25. });

复制代码

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

1. bot.hears("Withdraw 0.7 TON", (ctx) => {
   , M7 S& t- ?" T) a
2. const msg_body = beginCell().storeUint(3, 32).storeCoins(toNano(`0.7`))endCell();

复制代码

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

) s0 d( M/ D; k/ Q3 I% }0 o

1. let link = https://test.tonhub.com/transfer/${
   
2.   process.env.SC_ADDRESS
   * U, s* G. Y9 w5 y# [
3. }?${as.stringify({
   ) j4 ?6 D- U) C& ]
4.   text: "Withdraw 0.7 TON",
   , @. T$ f2 a7 r1 d# {
5.   amount: toNano('0.05').toString (10),
   ) d- K! F4 C$ K+ G4 S* M2 _
6.   bin: msg_body.toBoc({ idx: false }).toString("base64"),
   ) d7 l4 r3 O) s, b2 N
7. })}`;

复制代码

然后编辑机器人信息：

1. ctx.reply("To withdraw 0.7 TON please sign a transaction:", {
   ; D0 v* f  v9 Q2 m  T
2.     reply_markup: {
   
3.         inline_keyboard: [
   
4.             [{
   
5.                 text: "Sign transaction",
   . e  P) H# r% t7 U1 F
6.                 url: link,
   . T# R0 R1 k2 P
7.             }]
   
8.         ]
   ( [/ ~$ t) j9 o0 i4 B
9.     }
   ' B3 c9 W6 C$ u
10. });

复制代码

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

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

1 i! S3 f+ T  F" t8 z* H

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

1. bot.on(message("web_app_data"), (ctx) => ctx.reply("ok"));
   # u& ?& V/ ]; j+ n/ h8 [

复制代码

您还需要从 telegraf/filters:

1. import { message } from "telegraf/filters";
   

复制代码

您可以在这里发送贴纸或消息，但要过滤网络应用程序的数据。在这里，您将收到从网络应用程序发送的数据。需要注意的是，这是用于关闭的，因此一旦运行 sendData 方法，网络应用程序就会关闭。
& T# A9 t* y/ R8 r. i' |0 f; @
结论

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

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

: `9 R/ C1 \; G% `3 g





. Y1 t3 b$ h  R; E
, H; v1 w' K$ f( |2 s) j

  |5 i) l- v! o6 N
. D  x. G; h, R8 G! b3 @8 T3 u, Y! ~
6 H: X$ {8 x( f


/ H, J0 u; P4 `3 x

: D. \8 Y& O% B$ o