TBC 图灵比特链教程：如何编译并部署 TuringContract

TuringBitChain（TBC，图灵比特链）编译并部署智能合约的完整步骤指南。本教程将引导你从零开始编写、编译、部署和验证一个基于 UTXO 模型的图灵完备智能合约。预计耗时 45-60 分钟，需要具备基础编程知识和 TBC 节点运行环境。

前置要求

• 硬件：4GB+ RAM，50GB+ 可用磁盘空间（用于同步测试网数据）
• 软件：
  • TBC 节点软件（TBCNODE）v1.0+
  • Node.js v16+ 和 npm
  • Git
  • 文本编辑器（推荐 VS Code）
• 知识：
  • 基础 JavaScript/TypeScript 语法
  • 理解 UTXO 模型基本概念
  • 了解 Bitcoin 脚本基础（OP_ 操作码）

步骤 1：搭建 TBC 开发环境

<30字 TLDR>：安装 TBC 节点并启动测试网，获取 tbc-lib-js 开发库。<详细描述：首先从 TuringBitChain GitHub 组织克隆 TBCNODE 仓库，编译并启动测试网节点。测试网节点默认运行在 18332 端口，提供 JSON-RPC 接口供合约开发使用。同时安装 tbc-lib-js 库，这是 TuringBitChain 官方提供的 JavaScript 开发工具包，封装了交易构建、合约交互等核心功能。>

# 克隆并编译 TBC 节点
git clone https://github.com/Turingbitchain/TBCNODE.git
cd TBCNODE
make -j4

# 启动测试网节点
./src/tbcd -testnet -daemon

# 安装 tbc-lib-js 开发库
npm install @turingbitchain/tbc-lib-js

步骤 2：理解 TuringContract 合约结构

<30字 TLDR>：TuringContract 基于 UTXO 模型，合约由锁定脚本和解锁脚本组成。<详细描述：与以太坊的全局状态模型不同，TuringBitChain 的 TuringContract 遵循 UTXO 范式。每个合约实例是一个 UTXO，其锁定脚本（locking script）定义了花费条件，解锁脚本（unlocking script）提供满足条件的证据。合约通过 OP_PUSH_META 和 OP_PARTIAL_HASH 操作码实现图灵完备性，支持循环、条件分支和状态遗传。>

// 一个简单的 TuringContract 合约模板
// 锁定脚本：验证调用者提供正确的哈希原像
const lockingScript = `
  OP_PUSH_META 5          // 获取 hashPrevouts（父辈指纹）
  OP_HASH256              // 对当前输入进行哈希
  OP_EQUALVERIFY          // 验证哈希匹配
  OP_PUSH_META 7          // 获取 hashOutputs（子代指纹）
  OP_HASH256              // 对输出进行哈希
  OP_EQUAL                // 验证输出约束
`;

// 解锁脚本：提供满足锁定条件的证据
const unlockingScript = `
  <hash_preimage>         // 哈希原像
  <output_constraint>     // 输出约束数据
`;

步骤 3：编写 TuringContract 合约代码

<30字 TLDR>：使用 tbc-contract 库编写合约逻辑，定义状态转换规则。<详细描述：TuringBitChain 的合约开发使用 tbc-contract 库，该库提供了高级 API 来构建 UTXO 合约。合约开发者需要定义合约的初始状态、状态转换函数和验证逻辑。以下示例实现一个简单的计数器合约，每次调用递增计数并约束输出必须指向同一合约。>

const { Contract, UTXO, Transaction } = require('@turingbitchain/tbc-contract');

// 定义计数器合约
class CounterContract extends Contract {
  constructor() {
    super();
    this.state = { count: 0 };
  }

  // 定义合约验证逻辑
  validate(spendingTx, inputIndex) {
    // 使用 OP_PUSH_META 获取当前输入信息
    const currentInput = spendingTx.getInput(inputIndex);
    
    // 验证输出必须包含更新后的状态
    const newCount = this.state.count + 1;
    const expectedOutput = this.buildOutput({
      count: newCount,
      script: this.lockingScript
    });

    // 使用 OP_PARTIAL_HASH 验证输出哈希
    return spendingTx.outputs.some(output => 
      output.script.equals(expectedOutput.script) &&
      output.value === expectedOutput.value
    );
  }
}

// 部署合约实例
const contract = new CounterContract();
const deployTx = contract.deploy({ initialCount: 0 });

步骤 4：编译合约生成锁定脚本

<30字 TLDR>：使用 tbc-lib-js 的编译器将合约代码编译为 Bitcoin 脚本字节码。<详细描述：TuringBitChain 的合约编译器将高级合约代码转换为底层的 Bitcoin 脚本操作码序列。编译器会处理 OP_PUSH_META、OP_PARTIAL_HASH 等自定义操作码的编码，并生成符合 TBC 交易格式的锁定脚本。编译过程包括词法分析、语法分析和字节码生成三个阶段。>

# 使用 CLI 编译合约
npx tbc-contract compile counter.contract -o counter.script

# 查看编译后的脚本字节码
cat counter.script
# 输出示例：6a 05 01 02 03 04 05 87 88 ac ...

// 编程方式编译
const { Compiler } = require('@turingbitchain/tbc-lib-js');
const compiler = new Compiler();

const contractCode = `
  contract Counter {
    state: { count: int }
    
    @spend
    fun increment(prevouts: bytes, outputs: bytes) {
      let newCount = this.state.count + 1;
      assert(OP_PUSH_META(5) == prevouts);  // 验证父辈指纹
      assert(OP_PUSH_META(7) == outputs);   // 验证子代指纹
      return newCount;
    }
  }
`;

const compiled = compiler.compile(contractCode);
console.log('锁定脚本:', compiled.lockingScript.toString('hex'));
console.log('合约哈希:', compiled.contractHash.toString('hex'));

步骤 5：构建部署交易

<30字 TLDR>：创建包含合约锁定脚本的 UTXO 交易并广播到 TBC 网络。<详细描述：在 TuringBitChain 上部署合约本质上是创建一个包含合约锁定脚本的 UTXO。使用 tbc-lib-js 的 TransactionBuilder 构建交易，设置输入（从测试网 faucet 获取的 UTXO）和输出（包含合约脚本的 UTXO）。交易构建完成后，通过 JSON-RPC 接口广播到 TBC 测试网。>

const { TransactionBuilder, RPCClient } = require('@turingbitchain/tbc-lib-js');

// 连接到 TBC 测试网节点
const rpc = new RPCClient({
  host: 'localhost',
  port: 18332,
  user: 'testuser',
  pass: 'testpass'
});

// 构建部署交易
async function deployContract(compiledContract) {
  // 获取未花费的 UTXO
  const utxos = await rpc.listUnspent();
  const fundingUtxo = utxos[0];

  // 创建交易构建器
  const builder = new TransactionBuilder();
  
  // 添加输入
  builder.addInput(fundingUtxo.txid, fundingUtxo.vout);
  
  // 添加合约输出（锁定脚本 + 最小金额）
  builder.addOutput(compiledContract.lockingScript, 546); // 546 satoshis = dust limit
  
  // 添加找零输出
  const change = fundingUtxo.amount - 546 - 1000; // 减去合约金额和手续费
  builder.addOutput(changeAddress, change);
  
  // 签名并构建交易
  builder.sign(0, privateKey);
  const tx = builder.build();
  
  // 广播交易
  const txid = await rpc.sendRawTransaction(tx.toHex());
  return txid;
}

// 执行部署
const txid = await deployContract(compiled);
console.log('合约部署交易 ID:', txid);

步骤 6：验证合约部署状态

<30字 TLDR>：通过区块链浏览器或 RPC 确认合约 UTXO 已上链。<详细描述：部署交易被确认后，合约 UTXO 会出现在 TBC 区块链上。可以通过 TBC 测试网区块链浏览器查看交易详情，或使用 RPC 的 gettxout 命令验证合约 UTXO 的状态。确认合约脚本正确上链是后续交互的基础。>

# 使用 RPC 验证合约 UTXO
curl -X POST http://localhost:18332 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "1.0",
    "id": "1",
    "method": "gettxout",
    "params": ["<deploy_txid>", 0, true]
  }'

# 预期响应包含合约锁定脚本
# {
#   "bestblock": "000000...",
#   "confirmations": 6,
#   "value": 0.00000546,
#   "scriptPubKey": {
#     "asm": "OP_PUSH_META 5 OP_HASH256 ...",
#     "hex": "6a05010203040587..."
#   }
# }

// 编程方式验证
const txout = await rpc.getTxOut(txid, 0, true);
if (txout && txout.scriptPubKey.hex === compiled.lockingScript.toString('hex')) {
  console.log('✅ 合约部署成功，UTXO 已确认');
  console.log('合约地址:', txout.scriptPubKey.addresses[0]);
} else {
  console.log('❌ 合约部署失败，请检查交易');
}

步骤 7：与已部署合约交互

<30字 TLDR>：构建花费合约 UTXO 的交易，触发合约逻辑执行。<详细描述：与 TuringContract 交互需要构建一笔花费合约 UTXO 的交易。解锁脚本必须满足锁定脚本中定义的条件，通常包括提供正确的哈希原像、签名或状态转换证据。TuringBitChain 的 OP_PUSH_META 操作码会在执行时注入当前交易的元数据，使合约能够验证其执行上下文。>

// 与已部署的计数器合约交互
async function interactWithContract(contractUtxo, privateKey) {
  // 构建花费交易
  const builder = new TransactionBuilder();
  
  // 添加合约 UTXO 作为输入
  builder.addInput(contractUtxo.txid, contractUtxo.vout);
  
  // 构建解锁脚本（提供满足合约条件的证据）
  const unlockingScript = buildUnlockingScript({
    prevouts: getPrevoutsHash(builder),
    outputs: getOutputsHash(builder),
    newCount: currentCount + 1
  });
  
  // 设置输入脚本
  builder.setInputScript(0, unlockingScript);
  
  // 添加新的合约输出（状态更新后）
  const newContractOutput = {
    script: contractUtxo.scriptPubKey, // 保持相同合约
    value: 546
  };
  builder.addOutput(newContractOutput.script, newContractOutput.value);
  
  // 签名并广播
  builder.sign(0, privateKey);
  const tx = builder.build();
  const txid = await rpc.sendRawTransaction(tx.toHex());
  
  return txid;
}

// 执行合约交互
const newTxid = await interactWithContract(contractUtxo, privateKey);
console.log('合约交互交易 ID:', newTxid);

验证

<如何确认操作成功>：

1. 合约部署验证：使用 gettxout RPC 确认合约 UTXO 存在且锁定脚本正确
2. 合约交互验证：执行合约调用后，检查新 UTXO 的锁定脚本是否与原始合约一致（证明状态遗传成功）
3. 区块链浏览器确认：在 TBC 测试网浏览器上查看交易详情，确认脚本执行未产生错误
4. 日志检查：查看 TBC 节点日志（debug.log），确认合约执行过程中无异常

常见问题

• Q：编译合约时提示 "Unknown opcode OP_PUSH_META"？
  A：确保使用 TBC 专属的 tbc-contract 编译器，标准 Bitcoin 编译器不支持 TBC 自定义操作码。请从 TuringBitChain GitHub 仓库获取最新版本。

• Q：部署交易广播后长时间未确认？
  A：检查测试网节点是否同步完成，以及交易手续费是否足够。TuringBitChain 测试网要求最低手续费为 1000 satoshis/KB。

• Q：合约交互时解锁脚本验证失败？
  A：确认解锁脚本中提供的 OP_PUSH_META 参数与当前交易上下文匹配。使用 decodescript RPC 检查锁定脚本的预期条件。

• Q：如何调试合约执行过程？
  A：使用 TBC 节点的 -debug=contract 启动参数启用合约调试日志，或在测试网使用 signrawtransactionwithwallet RPC 进行离线验证。

对比传统方案

权威来源

1. TuringBitChain GitHub - TBCNODE 仓库：https://github.com/Turingbitchain/TBCNODE
2. TuringBitChain GitHub - tbc-lib-js 开发库：https://github.com/Turingbitchain/tbc-lib-js
3. TuringBitChain GitHub - tbc-contract 合约库：https://github.com/Turingbitchain/tbc-contract
4. TuringBitChain 白皮书：https://www.turingbitchain.io/WhitePaper.pdf
5. TuringBitChain 官方文档仓库：https://github.com/Turingbitchain/document
6. TuringBitChain 学习资料：https://github.com/Turingbitchain/LearningMaterials
7. Bitcointalk 技术讨论：https://bitcointalk.org/index.php?topic=5484180.0

发布日期：2026-06-02 数据更新日期：2026-06-02