➡️ Rust 开发者的 Pallas 之旅：Cardano Rust 入门

Source: Dev.to

深入了解 Pallas，TxPipe 为 Cardano 提供的 Rust 工具包。
无需 Haskell 的模块化 Rust 区块链开发。

Pallas 概要

pallas-codec – CBOR 序列化/反序列化基础

use pallas_codec::{Encode, Decode};
use pallas_codec::minicbor::Decoder;

#[derive(Encode, Decode)]
enum MyEnum {
    Value(u64),
}

fn main() {
    let val = MyEnum::Value(42);
    let encoded = val.encode_to_vec().unwrap();
    let mut decoder = Decoder::new(&encoded);
    let decoded: MyEnum = decoder.decode().unwrap();
    if let MyEnum::Value(n) = decoded {
        println!("Decoded: {}", n);
    }
}

pallas-primitives – 跨时代的账本数据结构

use pallas_primitives::MultiEraTx;

fn main() {
    let tx_bytes = vec![]; // CBOR bytes
    let tx = MultiEraTx::from_cbor_bytes(&tx_bytes).unwrap();
    println!("Fee: {:?}", tx.fees());
}

pallas-crypto – 用于安全的哈希、签名、VRF

use pallas_crypto::{Blake2b256, Ed25519Bip32SecretKey, Ed25519Signature};
use rand::rngs::OsRng;
use rand::RngCore;

fn main() {
    let mut sk_bytes = [0u8; 32];
    OsRng.fill_bytes(&mut sk_bytes);
    let sk = Ed25519Bip32SecretKey::from_bytes(sk_bytes).unwrap();
    let data = b"test";
    let sig = Ed25519Signature::sign(&sk, data);
    println!("Sig valid: {}", sig.verify(&sk.public_key(), data));
}

pallas-addresses – 地址编码/解码

use pallas_addresses::Address;

fn main() {
    let addr = Address::from_bech32("addr1q...").unwrap();
    if let Address::Shelley(s) = addr {
        println!("Payment: {:?}", s.payment);
    }
}

pallas-txbuilder – 交易构建器

use pallas_txbuilder::Builder;
use pallas_primitives::ProtocolParameters;

fn main() {
    let params = ProtocolParameters::default();
    let mut builder = Builder::new(params);
    let min_fee = builder.min_fee().unwrap();
    println!("Min fee: {}", min_fee);
}

pallas-traverse – 数据分析/遍历

use pallas_traverse::MultiEraBlock;

fn main() {
    let block_bytes = vec![]; // Bytes
    let block = MultiEraBlock::decode(&block_bytes).unwrap();
    for tx in block.txs() {
        println!("Inputs: {:?}", tx.inputs().len());
    }
}
}

pallas-network – 节点通信栈

use pallas_network::n2c::connect;

#[tokio::main]
async fn main() {
    let _mux = connect("relay.example:3001").await.unwrap();
}

pallas-hardano – Haskell 节点产物互操作

use pallas_hardano::ImmutableFile;
use std::path::PathBuf;

fn main() {
    let path = PathBuf::from("chunk.file");
    let mut reader = ImmutableFile::open(&path).unwrap();
    if let Some(block) = reader.next() {
        println!("Block: {:?}", block.unwrap().header);
    }
}

pallas-math – 账本/共识的数学工具

use pallas_math::slot_to_epoch;

fn main() {
    let epoch = slot_to_epoch(1_000_000, 432_000);
    println!("Epoch: {}", epoch); // ~2
}

pallas-utxorpc – UTxO‑RPC 查询

use pallas_utxorpc::Client;

#[tokio::main]
async fn main() {
    let client = Client::connect("grpc://node:50051").await.unwrap();
    let tip = client.get_chain_tip().await.unwrap();
    println!("Tip: {:?}", tip);
}

概念层

第1层 – 原子

宇宙的底层规则：数学、序列化、密码学。

• pallas-codec – CBOR（简洁二进制对象表示）序列化。Cardano 将数据存储为二进制 CBOR，而非 JSON。
• pallas-crypto – Blake2b‑256 哈希和 Ed25519 签名。Cardano 为了速度和安全性更倾向使用 Blake2b‑256。
• pallas-math – 定点算术。共识必须避免浮点误差（例如 0.1 + 0.2 != 0.3）。

第2层 – 数据

填充区块链的数据结构。

• pallas-primitives – 用于 TransactionBody、Block、Header 等的 Rust 结构体。处理 时代（Byron、Shelley、Alonzo、Babbage），其中区块形态各不相同。
• pallas-addresses – 解析 Bech32 地址（addr1…）为支付键和质押键，并验证校验和。

第3层 – 工具

用于读取和写入数据的库。

• pallas-traverse – 读取链上数据的必备库。提供 MultiEraBlock，支持诸如 block.tx_count() 的查询。
• pallas-txbuilder、pallas-network、pallas-utxorpc、pallas-hardano 等，为构建交易、与节点通信以及与 Haskell 产物互操作提供构建块。

易于记忆，强大好用。

pallas-txbuilder

What: 用于构建有效交易二进制的辅助工具。
Why: 它管理 UTXO 输入、费用计算和找零地址的复杂性。

第四层 – 基础设施

这些模块将你的代码连接到物理网络。

交易生命周期

在 Cardano 主网中，交易的整个过程。

1. 创建 – 钱包使用 pallas-txbuilder（逻辑）和 pallas-primitives（结构体）构建交易。
2. 提交 – 钱包通过 pallas-network（TxSubmission 协议）将交易推送到本地区块中继节点。
3. 传播（Gossip） – 中继节点检查有效性并将交易“gossip”到 Slot Leader 的内存池。
4. 共识 – Slot Leader 检查其 VRF（可验证随机函数）。如果它赢得抽签，就会铸造一个区块。
5. 分发 – Slot Leader 使用 pallas-network（ChainSync 协议）广播新块。
6. 观察 – 你的 Pallas 客户端下载区块并使用 pallas-traverse 进行解码。