合约中的比特币

/// 合约读取的 BTC 区块头至少要比锚定块低这么多个区块：每个网络上都是 6。
const BTC_QUERY_DEPTH: u32 = 6;

/// BTC 区块 `height` 的区块头；深度还不够、读不了时 revert。
pub fn header_at(height: u32) -> Result<btc::BlockHeader, Vec<u8>> {
    // 区块太浅时 btc_header 会 trap，所以先检查，再带着原因 revert
    let deepest = sdk::btc_anchor_height().checked_sub(BTC_QUERY_DEPTH);
    if deepest.is_none_or(|deepest| height > deepest) {
        return Err(b"the block is not deep enough yet".to_vec());
    }
    btc::BlockHeader::parse(&sdk::btc_header(height)).ok_or(b"malformed header".to_vec())
}

/// 一笔交易，以及把它定位到某个 BTC 区块里的 Merkle 证明。
pub struct Proof<'a> {
    /// BTC 区块的高度。
    pub height: u32,
    /// 这笔交易，序列化时不带见证数据。
    pub raw_tx: &'a [u8],
    /// 它在区块中的位置。
    pub index: u32,
    /// 它的 Merkle 分支，从叶子往上。
    pub branch: &'a [[u8; 32]],
    /// 这个区块的 coinbase 交易，不带见证数据。
    pub coinbase_tx: &'a [u8],
    /// coinbase 的 Merkle 分支：与 `branch` 一样长。
    pub coinbase_branch: &'a [[u8; 32]],
}

/// 检查已证明交易的输出 `vout` 付款给 `script`；返回 txid 和聪数。
pub fn proven_payment(
    proof: &Proof<'_>,
    vout: u32,
    script: &[u8],
) -> Result<([u8; 32], u64), Vec<u8>> {
    let header = header_at(proof.height)?;
    let txid = btc::verify_tx_inclusion(
        &header,
        proof.raw_tx,
        proof.index,
        proof.branch,
        proof.coinbase_tx,
        proof.coinbase_branch,
    )
    .ok_or(b"the transaction is not in that block".to_vec())?;
    let outputs = btc::parse_outputs(proof.raw_tx).ok_or(b"malformed transaction".to_vec())?;
    let output = usize::try_from(vout)
        .ok()
        .and_then(|i| outputs.get(i))
        .ok_or(b"no such output".to_vec())?;
    if output.script_pubkey != script {
        return Err(b"the output pays another script".to_vec());
    }
    Ok((txid, output.value))
}

/// 把输出 (txid, vout) 标记为已使用；第二次领取同一个输出会 revert。
pub fn use_once(txid: &[u8; 32], vout: u32) -> Result<(), Vec<u8>> {
    let key = [b"used".as_slice(), txid, &vout.to_le_bytes()].concat();
    if storage::get(&key).is_some() {
        return Err(b"already claimed".to_vec());
    }
    storage::set(&key, &[1]);
    Ok(())
}

[dependencies]
bitcoin = "0.32"
borsh = "1"
hex = "0.4"

//! 用从 bitcoind 读到的区块，构造 `btc::verify_tx_inclusion` 所检查的证明。
use bitcoin::consensus::serialize;
use bitcoin::hashes::{sha256d, Hash};
use bitcoin::{Block, Transaction};

/// 证明中把一笔交易定位到它所在区块的那几部分。
pub struct InclusionProof {
    /// 这笔交易，不带见证数据。
    pub raw_tx: Vec<u8>,
    /// 它的 Merkle 分支，从叶子往上。
    pub branch: Vec<[u8; 32]>,
    /// 这个区块的 coinbase 交易，不带见证数据。
    pub coinbase_tx: Vec<u8>,
    /// coinbase 的 Merkle 分支。
    pub coinbase_branch: Vec<[u8; 32]>,
}

/// 不带见证数据的交易：也就是它的 txid 所哈希的那些字节。
pub fn without_witness(tx: &Transaction) -> Vec<u8> {
    let mut stripped = tx.clone();
    for input in &mut stripped.input {
        input.witness.clear();
    }
    serialize(&stripped)
}

/// 第 `index` 笔交易的 Merkle 分支，从叶子往上，按内部字节序。
pub fn merkle_branch(txids: &[[u8; 32]], mut index: usize) -> Vec<[u8; 32]> {
    let mut level = txids.to_vec();
    let mut branch = Vec::new();
    while level.len() > 1 {
        if level.len() % 2 == 1 {
            level.push(level[level.len() - 1]); // 节点数为奇数的一层，把最后一个节点和它自己配对
        }
        branch.push(level[index ^ 1]);
        level = level
            .chunks(2)
            .map(|pair| sha256d::Hash::hash(&[pair[0], pair[1]].concat()).to_byte_array())
            .collect();
        index /= 2;
    }
    branch
}

/// `block` 中第 `index` 笔交易的证明。
pub fn inclusion_proof(block: &Block, index: usize) -> InclusionProof {
    let txids: Vec<[u8; 32]> = block
        .txdata
        .iter()
        .map(|tx| tx.compute_txid().to_byte_array())
        .collect();
    InclusionProof {
        raw_tx: without_witness(&block.txdata[index]),
        branch: merkle_branch(&txids, index),
        coinbase_tx: without_witness(&block.txdata[0]),
        coinbase_branch: merkle_branch(&txids, 0),
    }
}

/// 示例 btc-payment-trigger 中 `claim` 的 Borsh 参数，写成十六进制，供 `--args` 使用。
pub fn claim_args(
    block: &Block,
    height: u32,
    index: usize,
    vout: u32,
    beneficiary: [u8; 32],
) -> String {
    let p = inclusion_proof(block, index);
    let index = u32::try_from(index).expect("a block holds fewer than 2^32 transactions");
    let args = (
        height,
        p.raw_tx,
        index,
        p.branch,
        p.coinbase_tx,
        p.coinbase_branch,
        vout,
        beneficiary,
    );
    hex::encode(borsh::to_vec(&args).expect("encoding plain values cannot fail"))
}

/// 携带这笔操作的 BTC 交易付给 `script` 的聪数，以及它的 txid。
pub fn paid_by_this_op(script: &[u8]) -> Result<([u8; 32], u64), Vec<u8>> {
    let tx = sdk::native_tx().ok_or(b"send this op through path C".to_vec())?;
    let mut paid = 0u64;
    for output in tx.outputs.iter().filter(|o| o.script == script) {
        paid = paid.checked_add(output.value).ok_or(b"overflow".to_vec())?;
    }
    Ok((tx.txid, paid))
}

//! 路径 C 付款检查的本机测试，在模拟宿主上运行。
#![cfg(not(target_arch = "wasm32"))]

use ksana_contract_sdk::{mock, NativeOutput, NativeTx};

const ALICE: [u8; 32] = [0xa1; 32];
const CONTRACT: [u8; 32] = [0xc0; 32];

#[test]
fn counts_what_the_carrying_transaction_pays() {
    mock::reset();
    let script = [&[0x51, 0x20][..], &[7; 32]].concat(); // 一个 P2TR 输出脚本
    let pay = |value| NativeOutput {
        value,
        script: script.clone(),
    };
    let outputs = vec![pay(700), pay(300)];
    mock::set_native_tx(Some(NativeTx {
        txid: [3; 32],
        outputs,
    }));
    let paid = mock::with_context(ALICE, CONTRACT, || snippets::paid_by_this_op(&script));
    assert_eq!(paid, Ok(([3; 32], 1_000)));
    mock::set_native_tx(None); // 从这里起是路径 B 操作
    let paid = mock::with_context(ALICE, CONTRACT, || snippets::paid_by_this_op(&script));
    assert_eq!(paid, Err(b"send this op through path C".to_vec()));
}