【Rust】UTXOのロジックで残高照会の仕組みを実装したい

ロジック
1. blockからトランザクションデータを抽出する
2. トランザクションデータのsendに自分のアドレスがあればamountからマイナス
3. トランザクションデータのreceiverに自分のアドレスがあればamountをプラス
4. 2・3をループで回して、合計値をウォレットのGUIで表示

// gui表示
async fn handle_balance()-> axum::response::Html<String> {

    let balance = balance().unwrap();

    let tera = tera::Tera::new("templates/*").unwrap();

    let mut context = tera::Context::new();
    context.insert("title", "Index page");
    context.insert("balance", &balance);

    let output = tera.render("balance.html", &context);
    axum::response::Html(output.unwrap())
}

// balance計算
fn balance()-> Result<i32, Box<dyn std::error::Error>>{
    // アドレスの読み込み
    let contents = std::fs::read_to_string("secret.pem")
        .expect("something went wrong reading the file");
    let secret_pem = contents.trim();

    let secret_key = secret_pem.parse::<SecretKey>().unwrap();
    let private_key_serialized = hex::encode(&secret_key.to_bytes());

    let public_key = secret_key.public_key();
    let address = new_address(&public_key); 

    let mut balance: i32 = 0;
    for result in BufReader::new(File::open("blocks.txt")?).lines() {
        let l = result?;
        let param:Block = serde_json::from_str(&l).unwrap();
        for transaction in param.transactions {
            if transaction.receiver == address {
                balance += transaction.amount;
            } else if transaction.sender == address{
                balance -= transaction.amount; 
            }
        }
    }
    println!("balance is {}", balance);
    return Ok(balance);
}

うん、これは特に問題ないですね。

【Rust】ファイルの先頭行のみ読み込みたい

linesをforループで回して、1回でbreakする。。。 絶対違うように思うが、他の方法がわからん…

fn genesis_check()-> Result<(), Box<dyn std::error::Error>> {
    for result in BufReader::new(File::open("blocks.txt")?).lines() {
        let l = result?;
        let param:Block = serde_json::from_str(&l).unwrap();
        println!("{:?}", param.hash);
        break;
    }
    Ok(())
}

【Blockchain】minerがPoWした後のサーバ側の処理を考える

/chain
リクエストに対し、サーバが保持しているブロックチェーンを返すパス・変数

関数 chain_verify
マイニングを完了したマイナーから送られてきたブロックチェーンの中身をチェックして、問題なければブロックチェーンを追記する。
【処理内容】
1. first blockが改竄されていないか
2. Previous blockのハッシュ値を使用し、PoWによりハッシュ値が正しく計算されているか
3. 報酬用のトランザクションを作成する(報酬額はstaticで定義する、マイナーのアドレスが必要)
4. 生成したブロックを前のブロックに繋げて保存する

– 3.でマイナーへ報酬用のトランザクションを作成する際に、マイナーのアドレスと、大元のアドレスが必要になる。
– 本来であれば、上記1~4に加えて、merkle treeの検証も必要
– ブロックチェーンにつながっているブロックのすべてのハッシュ値を計算する場合は、計算処理が多くなりそう

【Rust】Rustでマークルツリーを作りたい

use sha2::{Digest, Sha256};

#[derive(Debug, Clone)]
enum Position {
    Right,
    Left,
}

#[derive(Debug, Clone)]
struct Node {
    left: String,
    right: String,
    parent: String,
    sibling: String,
    position: Position,
    data: String,
}

fn hash(data: String) -> String {
    let h = Sha256::digest(data.clone());
    hex::encode(h).to_string()
}

fn sha256hash(right_data: String, left_data: String) -> String {
        let s = format!("{}{}", right_data, left_data);
        let h = Sha256::digest(s);
        hex::encode(h).to_string()
}

#[derive(Debug, Clone)]
struct Tree {
    leaves: Vec<Node>,
    layer: Vec<Node>,
    root: String,
}

impl Tree {
    fn build_layer(&mut self) {
        let mut new_layer: Vec<Node> = Vec::new();

        if self.layer.len() % 2 == 1 {
            self.layer.push(self.layer[self.layer.len() - 1].clone());
        }

        for i in (0..self.layer.len()).step_by(2) {
            let parent_data = sha256hash(self.layer[i].data.clone(), self.layer[i+1].data.clone());
            let left = Node {left: "".to_string(), right: "".to_string(), parent: parent_data.clone(), sibling: self.layer[i+1].data.clone(), position: Position::Left, data: self.layer[i].data.clone()};
            let right = Node {left: "".to_string(), right: "".to_string(), parent: parent_data.clone(), sibling: self.layer[i].data.clone(), position: Position::Right, data: self.layer[i+1].data.clone()};
            let parent = Node {left: self.layer[i].data.clone(), right: self.layer[i+1].data.clone(), parent: "".to_string(), sibling: self.layer[i].data.clone(), position: Position::Left, data: parent_data.clone()};
            new_layer.push(parent.clone());
            self.leaves.push(left.clone());
            self.leaves.push(right.clone());
            self.leaves.push(parent.clone());
        }
        self.layer = new_layer;
    }

    fn build_tree(&mut self) {
        while self.layer.len() > 1 {
            let _ = self.build_layer();
        }
        self.root = self.layer[0].data.clone();
    }

    fn search(&mut self, data: String) -> Node {
        let hash_value = data.clone();
        let mut target = Node {left: "".to_string(), right: "".to_string(), parent: "".to_string(), sibling: "".to_string(), position: Position::Left, data: "".to_string()};
        for node in &self.leaves {
            if node.data == hash_value {
                let target: Node = node.clone();
            } 
        }
        return target
    }

    fn get_pass(&mut self, data: String) -> Vec<String>{
        let mut target = self.search(hash(data.clone()));
        let mut markle_pass: Vec<String> = Vec::new();
        markle_pass.push(target.data);
        while target.parent != "" {
            markle_pass.push(target.sibling);
            target = self.search(target.parent);
        }       
        return markle_pass
    }
}

fn merkle_root(v: Vec<&str>) -> String {
    let mut t = Tree {leaves: [].to_vec(), layer: [].to_vec(), root: "".to_string()};
    for n in v {
        let mut s =  Node {left: "".to_string(), right: "".to_string(), parent: "".to_string(), sibling: "".to_string(), position: Position::Left, data: hash(n.to_string())};
        t.layer.push(s.clone());
    }
    t.build_tree();
    t.root
}

fn main(){
    let v= vec!["aaa", "bbb", "ccc", "ddd", "eee", "fff", "gggg"];
    let m = merkle_root(v);
    println!("{}", m);
}

うーん….

【Rust】Rustで for i in range(0, 10, 2) をやりたい

step_by(n) が使える模様
ただし、これだと、iがイテレータになってしまうので、pythonでいう for i in range(0, 10, 2) にならない

fn main(){
    let v= vec![1, 2, 3, 4, 5, 6, 7];
    for i in v.into_iter().step_by(2) {
        println!("{}", i);
    }   
}

$ cargo run
Compiling sample v0.1.0 (/home/vagrant/dev/rust/sample)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.34s
Running `target/debug/sample`
1
3
5
7

正確にはこう↓

fn main(){
    let v= vec![1, 2, 3, 4, 5, 6, 7];
    for n in (0..v.len()).step_by(2) {
        println!("{}", v[n]);
    }   
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
Running `target/debug/sample`
1
3
5
7

なるほど、勉強になるね〜

【Rust】Vecへの要素の追加

appendではなく、pushを使う

fn main(){
    let mut layer: Vec<String> = vec!["hoge".to_string(), "fuga".to_string()];
    layer.push("aaa".to_string());
    println!("{:?}", layer);
}

[“hoge”, “fuga”, “aaa”]

    let mut layer: Vec<String> = vec!["hoge".to_string(), "fuga".to_string()];
    layer.push("aaa".to_string());
    println!("{:?}", layer[layer.len() - 1]);

“aaa”

これを応用して

#[derive(Debug, Clone)]
struct Tree {
    leaves: Vec<String>,
    layer: Vec<String>,
    root: String,
}

impl Tree {
    fn build_layer(&mut self) {
        let new_layer: Vec<String> = Vec::new();

        if self.layer.len() % 2 == 1 {
            self.layer.push(self.layer[self.layer.len() - 1].clone());
        }
    }
}

appendだと上手くいきませんね。

【Rust】structにenumとimplを使用したい

use sha2::{Digest, Sha256};

#[derive(Debug)]
enum Position {
    Right,
    Left,
}

#[derive(Debug)]
struct Node {
    left: String,
    right: String,
    sibling: String,
    position: Position,
    data: String,
}

impl Node {
    fn hash(&self) -> String {
        let h = Sha256::digest(self.data.clone());
        hex::encode(h).to_string()
    }
}

fn main(){
    let d = Node { left:"aaa".to_string(), right:"aaa".to_string(), sibling:"aaa".to_string(), position: Position::Left, data:"aaa".to_string()};
    println!("{:?}", d);
    println!("{:?}", d.hash());
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.24s
Running `target/debug/sample`
Node { left: “aaa”, right: “aaa”, sibling: “aaa”, position: Left, data: “aaa” }
“9834876dcfb05cb167a5c24953eba58c4ac89b1adf57f28f2f9d09af107ee8f0”

これで良いのか? なんか違うような気もするが、これでmerkle treeを作っていきたい。。。

【Rust】ファイルの有無によって処理を分けたい

use std::{fs::File, io::ErrorKind};

fn main(){
    let f = File::open("secret.pem");
    let f = match f {
        Ok(_) => (),
        Err(ref error) if error.kind() == ErrorKind::NotFound => println!("Not found"),
        Err(error) => {
            panic!("There was a problem opening the file: {:?}", error);
        } 
    };
    println!("OK");
}

何もしない場合は、Ok(_) => () と書いた。

【Rust】writeln!で後ろに改行が入った時に削除

writeln!でpemファイルを作成します。

env::set_var("RUST_BACKTRACE", "1");
    let secret_key = SigningKey::random(&mut OsRng);
    let secret_key_serialized = secret_key
        .to_pkcs8_pem(Default::default())
        .unwrap()
        .to_string();
    println!("Secret Key: \n{}", secret_key_serialized);

    let mut file = File::create("secret.pem").expect("file not found.");

    writeln!(file, "{}", secret_key_serialized).expect("can not write.");

すると、最後尾に2行改行が入ってしまいます。

-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgO7s4/UmqJ5+UWIIU
oL4XIxslh+htWtvTY7wZPp+usEKhRANCAAS/iV6WinhhKw8M/tkGNNwf2W+Vt+cd
d0hLjWQ9iZhjP7NxlPLoUjWERctvft3zPOktCedW5rzLIhVtj7rX2F4j
-----END PRIVATE KEY-----


これをstd::fs::read_to_stringで読み取ってパースしても、改行が入っているためエラーになってしまいます。
改行を指定しての文字列削除や文字列の置き換え(s.replace)だとうまくいかないのですが、
trim()だと、いい具合に最後2行の改行を削除してくれます。

    let mut file = File::create("secret.pem").expect("file not found.");

    writeln!(file, "{}", secret_key_serialized).expect("can not write.");

    let contents = std::fs::read_to_string("secret.pem")
        .expect("something went wrong reading the file");
    let secret_pem = contents.trim();
    println!("{}", secret_pem);

Secret Key:
—–BEGIN PRIVATE KEY—–
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgNMDcEubwpsVrs/TJ
YgiL/HFyb3hvOgF/QI3AwXWBFKmhRANCAARyuwFIbkPm5Q1zbd6DZbNMG35s7NmU
6QduJGRjofpwCrVaOorsjZASpG546WgoTof9eONpXYY92NY5hCvhPJrU
—–END PRIVATE KEY—–

—–BEGIN PRIVATE KEY—–
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgNMDcEubwpsVrs/TJ
YgiL/HFyb3hvOgF/QI3AwXWBFKmhRANCAARyuwFIbkPm5Q1zbd6DZbNMG35s7NmU
6QduJGRjofpwCrVaOorsjZASpG546WgoTof9eONpXYY92NY5hCvhPJrU
—–END PRIVATE KEY—–

素晴らしいですね。これ解決するのに半日かかりました。

【Rust】p256(ecdsa)でpemファイルを扱う

use p256::{
    ecdsa::{
        signature::{Signer, Verifier},
        SigningKey, VerifyingKey,
    },
    pkcs8::EncodePrivateKey,
    PublicKey, SecretKey,
};
use rand_core::OsRng;
use std::fs::OpenOptions;
use std::io::Write;

fn main(){
    let secret_key = SigningKey::random(&mut OsRng);
    let secret_key_serialized = secret_key
        .to_pkcs8_pem(Default::default())
        .unwrap()
        .to_string();
    println!("Secret Key: \n{}", secret_key_serialized);
    let secret_key = secret_key_serialized.parse::<SecretKey>().unwrap();

    let public_key = secret_key.public_key();
    let public_key_serialized = public_key.to_string();
    println!("Public Key: \n{}", public_key_serialized);
    let public_key = public_key_serialized.parse::<PublicKey>().unwrap();

    let signing_key: SigningKey = secret_key.into();
    let message = b"ECDSA proves knowledge of a secret number in the context of a single message";
    let signature = signing_key.sign(message);

    let verifying_key: VerifyingKey = public_key.into();
    assert!(verifying_key.verify(message, &signature).is_ok());
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 5.89s
Running `target/debug/sample`
Secret Key:
—–BEGIN PRIVATE KEY—–
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgqmVTGsuHMDgaN3TG
Jvsem2P1dA3l/wnRsxPfN8PTnUqhRANCAASv58iralPg2mOjuf28sSC8UuxqR4kD
u9tATiYXDvaU6BfmuI0tl0JsrZ2Brf1BkXtzbwBbiM2+h6+I6J55TU2p
—–END PRIVATE KEY—–

Public Key:
—–BEGIN PUBLIC KEY—–
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEr+fIq2pT4Npjo7n9vLEgvFLsakeJ
A7vbQE4mFw72lOgX5riNLZdCbK2dga39QZF7c28AW4jNvoeviOieeU1NqQ==
—–END PUBLIC KEY—–

p256とk256は微妙に違うのね。。これをpemファイルとして保存したい。