sendBatchRequest

批量提交多个独立请求。每个请求独立执行，单个请求失败不影响其他请求。

此外，当 signMessage 请求需要依赖前一个请求的结果时，可以通过 dependsOn 字段将它们关联。详见下方关联请求部分。

限制： 每次批量最多 5 个请求。

支持的方法

sendTransaction - 发送交易
signMessage - 签名消息
signTransaction - 签名交易
signAssociatedTransaction - 签名关联交易
encrypt - 加密
decrypt - 解密

用法

import { useTuringWallet } from "turing-wallet-provider";

const wallet = useTuringWallet();

const requests = [
  {
    method: "sendTransaction",
    params: {
      flag: "P2PKH",
      address: "recipient_address",
      satoshis: 10000,
      broadcastEnabled: true,
    },
  },
  {
    method: "signMessage",
    params: {
      message: "Hello World",
      encoding: "utf8",
    },
  },
];

const results = await wallet.sendBatchRequest(requests);

参数

type BatchRequestMethod =
  | "sendTransaction"
  | "signMessage"
  | "signTransaction"
  | "signAssociatedTransaction"
  | "encrypt"
  | "decrypt";

interface BatchRequest {
  method: BatchRequestMethod;     // 要调用的方法名
  params: object;                 // 对应方法的参数
  dependsOn?: string;             // 仅用于 signMessage，指定注入 txids 的字段名
}

字段	类型	说明
`method`	`BatchRequestMethod`	要调用的方法名
`params`	`object`	对应方法的参数，参见各方法文档
`dependsOn`	`string`	仅用于 `signMessage`，表示要将前一个请求产生的 txid 数组注入到本请求 `message`（JSON 字符串）中的字段名。详见关联请求

返回值

返回结果数组，每个元素对应一个请求的结果，顺序与输入一致。

type BatchResponse = Array<{
  txid?: string;       // sendTransaction 广播成功时的交易 ID
  txraw?: string;      // sendTransaction 不广播时的原始交易 hex
  txraws?: string[];   // signAssociatedTransaction 的签名结果
  address?: string;    // signMessage 返回的地址
  pubkey?: string;     // signMessage 返回的公钥
  sig?: string;        // signMessage 返回的签名
  message?: string;    // signMessage 返回的消息
  error?: string;      // 请求失败时的错误信息
}>;

字段	类型	说明
`txid`	`string`	`sendTransaction` 广播成功时的交易 ID
`txraw`	`string`	`sendTransaction` 不广播时的原始交易 hex
`txraws`	`string[]`	`signAssociatedTransaction` 的签名后交易数组
`address`	`string`	`signMessage` 返回的签名地址
`pubkey`	`string`	`signMessage` 返回的公钥
`sig`	`string`	`signMessage` 返回的签名
`message`	`string`	`signMessage` 返回的消息内容
`error`	`string`	请求失败时的错误信息

错误处理

const results = await wallet.sendBatchRequest(requests);

results.forEach((result, index) => {
  if (result.error) {
    console.error(`请求 ${index + 1} 失败:`, result.error);
  } else {
    console.log(`请求 ${index + 1} 成功:`, result);
  }
});

示例

批量转账

const batchTransfer = [
  {
    method: "sendTransaction",
    params: {
      flag: "P2PKH",
      address: "address1",
      satoshis: 10000,
      broadcastEnabled: true,
    },
  },
  {
    method: "sendTransaction",
    params: {
      flag: "P2PKH",
      address: "address2",
      satoshis: 20000,
      broadcastEnabled: true,
    },
  },
];

const results = await wallet.sendBatchRequest(batchTransfer);

results.forEach((result, index) => {
  if (result.error) {
    console.error(`请求 ${index + 1} 失败:`, result.error);
  } else {
    console.log(`请求 ${index + 1} 成功:`, result.txid);
  }
});

混合操作

const mixedOperations = [
  {
    method: "signMessage",
    params: {
      message: "Proof of ownership",
      encoding: "utf8",
    },
  },
  {
    method: "sendTransaction",
    params: {
      flag: "P2PKH",
      address: "recipient",
      satoshis: 50000,
      broadcastEnabled: true,
    },
  },
  {
    method: "encrypt",
    params: {
      message: "Sensitive data",
    },
  },
];

const results = await wallet.sendBatchRequest(mixedOperations);

关联请求

它解决什么问题？

有些业务流程要求："先发一笔（或多笔）链上交易，然后用钱包对一段消息签名，且消息内容中必须带上刚刚生成的 txid"。但 txid 在交易构造完成前无法预先知道，调用方没法把它写进 signMessage 的参数里。

dependsOn 就是为此设计的：在批量请求中，钱包会自动从前一个请求的结果里提取 txid 数组，并注入到后一个 signMessage 的消息 JSON 中。

如果不添加 dependsOn，批量里的两个请求会作为彼此独立的请求各自执行，互不影响。

使用条件

使用 dependsOn 时，批量请求必须满足：

恰好两个请求
第 1 个请求：signAssociatedTransaction 或 sendTransaction
第 2 个请求：signMessage，且 params.message 必须是合法 JSON 字符串（钱包要解析 JSON 后再写入字段）
dependsOn 的值为字符串，表示注入到该 JSON 中的字段名（如 "txids"）

注意：普通（非关联）的 signMessage 没有这个限制，message 可以是任意字符串。

注入的内容是什么？

钱包注入到 message JSON 的，始终是一个 txid 字符串数组（哪怕只有一个 txid，也会是长度为 1 的数组）。

第一个请求可能返回多个 txid（例如 STABLECOIN_CREATE / FT_MINT / POOLNFT_MINT 会返回两个；signAssociatedTransaction 也可能返回多个），钱包会把这些 txid 全部按顺序放进数组。下表列出钱包是如何从不同返回结构里提取出这个数组的：

第一个请求	第一个请求的返回结构	钱包如何提取 txid 数组
`signAssociatedTransaction`	`{ txraws: string[] }`	对 `txraws` 中的每一个 txraw 计算 txid，得到 `[txid1, txid2, ...]`
`sendTransaction`（`broadcastEnabled: true`，单 txid）	`{ txid: "txid1" }`	`["txid1"]`
`sendTransaction`（`broadcastEnabled: true`，多 txid）	`{ txid: "txid1,txid2" }`（逗号分隔）	按逗号拆分，得到 `["txid1", "txid2"]`
`sendTransaction`（`broadcastEnabled: false`，单 txraw）	`{ txraw: "hex1" }`	计算 txid，得到 `["txid1"]`
`sendTransaction`（`broadcastEnabled: false`，多 txraw）	`{ txraw: "hex1,hex2" }`（逗号分隔）	按逗号拆分后逐一计算 txid，得到 `["txid1", "txid2"]`

提示：sendTransaction 在 broadcastEnabled: false 且涉及多笔交易时（如 FT_MINT、POOLNFT_MINT、STABLECOIN_CREATE），返回的 txraw 是用逗号拼接的多个 hex，需要前一个先广播。这里钱包只是按逗号拆分后计算 txid，不负责广播。

注入位置

注入的字段名由 dependsOn 指定。例如 dependsOn: "txids" 表示：

JSON.parse(message).txids = [/* 提取出的 txid 数组 */];

最终 signMessage 真正签名的消息是注入后的完整 JSON 字符串。

执行流程

执行第 1 个请求（signAssociatedTransaction 或 sendTransaction）
按上表从结果中提取 txid 数组
解析第 2 个请求的 params.message（必须是 JSON 字符串），把 txid 数组写入 dependsOn 指定的字段
用注入后的完整 JSON 字符串作为 message 执行 signMessage

如果第 1 个请求失败，signMessage 不会执行，对应位置返回错误。

示例一：signAssociatedTransaction + signMessage（多 txid）

const requests = [
  {
    method: "signAssociatedTransaction",
    params: {
      sourceTxraw: "...",
      sourceUtxos: [
        {
          txId: "",
          outputIndex: 0,
          satoshis: 500,
          script: ftcode,
          scriptSigType: "tbc20",
        },
        {
          txId: "",
          outputIndex: 2,
          satoshis: 10000,
          script: p2pkh,
          scriptSigType: "p2pkh",
        },
      ],
      inputs: [
        [
          { outputIndex: 0, scriptSigType: "tbc20" },
          { outputIndex: 2, scriptSigType: "p2pkh" },
        ],
      ],
      outputs: [
        [
          { script: ftcode, satoshis: 500 },
          { script: fttape, satoshis: 0 },
          { script: p2pkh, satoshis: 8000 },
        ],
      ],
    },
  },
  {
    method: "signMessage",
    params: {
      message: JSON.stringify({
        action: "mint",
        amount: 100,
      }),
      encoding: "utf8",
    },
    dependsOn: "txids",
  },
];

const results = await wallet.sendBatchRequest(requests);

// results[0] => signAssociatedTransaction 的结果: { txraws: string[] }
// results[1] => signMessage 的结果: { address, pubkey, sig, message }
// 其中 message 为包含 txids 的完整 JSON，例如：
// { "action": "mint", "amount": 100, "txids": ["txid1", "txid2", ...] }

示例二：sendTransaction + signMessage（前置请求返回多个 txid）

下面的 STABLECOIN_CREATE 会返回两个 txid（以逗号拼接在 txid 字段中），钱包会自动按逗号拆分后注入。FT_MINT、POOLNFT_MINT 等同理。

const requests = [
  {
    method: "sendTransaction",
    params: {
      flag: "STABLECOIN_CREATE",
      ft_data: JSON.stringify({
        name: "USD Test",
        symbol: "USDT",
        decimal: 6,
        amount: 100000000,
      }),
      address: "",
      mint_message: "SourceChain: BSC, TXID: 34434...",
      broadcastEnabled: true,
      domain: "",
    },
  },
  {
    method: "signMessage",
    params: {
      message: JSON.stringify({
        action: "create_stablecoin",
      }),
      encoding: "utf8",
    },
    dependsOn: "txids",
  },
];

const results = await wallet.sendBatchRequest(requests);

// results[0] => sendTransaction 的结果: { txid: "txid1,txid2" }
// results[1] => signMessage 的结果: { address, pubkey, sig, message }
// 其中 message 为包含 txids 的完整 JSON，例如：
// { "action": "create_stablecoin", "txids": ["txid1", "txid2"] }

sendBatchRequest ​

支持的方法 ​

用法 ​

参数 ​

返回值 ​

错误处理 ​

示例 ​

批量转账 ​

混合操作 ​

关联请求 ​

它解决什么问题？ ​

使用条件 ​

注入的内容是什么？ ​

注入位置 ​

执行流程 ​

示例一：signAssociatedTransaction + signMessage（多 txid） ​

示例二：sendTransaction + signMessage（前置请求返回多个 txid） ​