BLOCKIFY

BLOCKIFY 是一个 Rust 区块链库，它提供了构建完整区块链应用程序或平台的构建块，让您可以专注于应用程序的高级功能，无需担心 块验证、数据序列化、区块链技术 和 加密操作 的底层细节。

实用功能

• 生成加密密钥对
• 使用加密密钥签名数据
• 将数据序列化为字节
• 哈希不同类型的数据
• 构建区块链
• 将块部署到区块链中
• 构建完整区块链应用程序的架构

使用方法

• 示例

    use blockify::{
    block::{LocalInstance, UnchainedInstance, Block},
    data::Metadata,
    record::{Record, SignedRecord}, SqliteChain, chain::Chain,
    };
    use serde::{Deserialize, Serialize};

    // Deriving `Record` does the magic 
    #[derive(Clone, Serialize, Deserialize, Record, Debug, PartialEq)]
    pub struct MarriageContract {
        bride_name: String,
        groom_name: String,
    }

    impl MarriageContract {
        pub fn new(bride_name: &str, groom_name: &str) -> Self {
            let (bride_name, groom_name) = (bride_name.to_owned(), groom_name.to_owned());
            Self {
                bride_name,
                groom_name,
            }
        }

        pub fn generate() -> Self {
            Self {
                bride_name: "Julian".to_owned(),
                groom_name: "Jolie".to_owned(),
            }
        }

        pub fn generate_records(amount: usize) -> Vec<SignedRecord<Self>> {
            let mut res = Vec::with_capacity(amount);
            (0..amount).for_each(|_| {
                match Self::generate().record(blockify::generate_ed25519_key_pair(), Default::default())
                {
                    Ok(v) => res.push(v),
                    Err(_) => unreachable!("Error occurs"),
                }
            });
            res
        }

    }

• 创建 Records 和 SignedRecords

    let contract = MarriageContract::new("John", "Julie");
    let keypair = blockify::generate_ed25519_keypair();
    let signature = contract.sign(&keypair).unwrap();
    let hash = contract.hash();
    let record = contract.record(keypair, Metadata::empty()).unwrap();

    assert_eq!(&hash, record.hash());
    assert_eq!(&signature, record.signature());
    assert!(record.verify().is_ok());

• 组装 Block

    let mut pool = LocalInstance::new(Metadata::empty(), 0);
    let all_records = MarriageContract::generate_records(10);
    all_records.clone().into_iter().for_each(|record| pool.append(record).unwrap());

• SqliteBlock 和 SqliteChain

    let chain_url = "target2/tests/marriagecontractchain/";
    std::fs::create_dir_all(chain_url).expect("could initialize directories");
    
    let mut chain = SqliteChain::new(chain_url).unwrap();
    let position = chain.append(&pool).expect("Error appending to SqliteChain");
    let block = position.block(&chain).expect("Error getting block by position");

    assert_eq!(&all_records, &*block.records().expect("Error retrieving records from block"));

贡献

欢迎所有形式的贡献。

依赖关系

许可证

MIT

lib.rs:

Record - record_derive

blockify 的 blockify::record::Record 的 derive 宏

推导 Record 的类型必须实现 Serialize + Deserialize

用法

use blockify::record::Record;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Record)]
pub struct MarriageContract {
  bride: String,
  groom: String,
}

#[derive(Serialize, Deserialize, Record)]
pub struct Detail<T> {
  val: T
}