Category: Blockchain

use reqwest::Client;
use serde::{Serialize, Deserialize};
use serde_json::{Value};

#[tokio::main]
async fn main() {

    let btc: String = "BTC".to_string();
    let btc_price: Value = get_price(btc).await.unwrap();
    println!("{}", btc_price);

    let eth: String = "ETH".to_string();
    let eth_price: Value = get_price(eth).await.unwrap();
    println!("{}", eth_price);
}

async fn get_price(code: String) -> Result<Value, Box<dyn std::error::Error>> {
    let mut url:String = "https://api.coinbase.com/v2/exchange-rates?currency=".to_string();
    url.push_str(&code);
    let contents = reqwest::get(url).await?.text().await?;
    let res: Value = serde_json::from_str(&contents).unwrap();
    println!("{:?}", res["data"]["rates"]["USD"]);
    Ok((res["data"]["rates"]["USD"]).clone())
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.97s
Running `target/debug/wallet`
String(“94359.295”)
“94359.295”
String(“3246.82”)
“3246.82”

処理速度が遅いが、取得はできる。
よし、さて、PoSでもやるか！

hex::decode(&public_key_hex)　でdecodeして、さらにfrom_sec1_bytesでpublic keyにします。

    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_hex = hex::encode(&public_key.to_sec1_bytes());
    println!("hex Public Key: \n{}", public_key_hex);

    let public_key_decode = hex::decode(&public_key_hex).unwrap();
    println!("decode Public Key: \n{:?}", &public_key_decode);

    let public_key = p256::PublicKey::from_sec1_bytes(&public_key_decode).expect("import error");

    println!("decode Public Key: \n{:?}", &public_key);

    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: Signature = signing_key.sign(message);

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

$ cargo run
// 省略
hex Public Key:
040b807b5e5fee8c91df858e09aa6dc085eae1b9b70783ce32ec68ad4994f9d16a991e277a1515a22e35d2d7935dec95946f31a2e3ea1e125a9067a177523063b0
decode Public Key:
[4, 11, 128, 123, 94, 95, 238, 140, 145, 223, 133, 142, 9, 170, 109, 192, 133, 234, 225, 185, 183, 7, 131, 206, 50, 236, 104, 173, 73, 148, 249, 209, 106, 153, 30, 39, 122, 21, 21, 162, 46, 53, 210, 215, 147, 93, 236, 149, 148, 111, 49, 162, 227, 234, 30, 18, 90, 144, 103, 161, 119, 82, 48, 99, 176]
decode Public Key:
PublicKey { point: AffinePoint { x: FieldElement(0x3B226D0B94EFABC8980328AB7FE8AE347D418871A770F1EFFE8A24FCAC9EE9DB), y: FieldElement(0x307BB7BAC4B807E9D59F65BEC20EC8AB54591BE07549140238927D01CA9152EF), infinity: 0 } }

おおお、このdecodeと署名の確認は本当に上手くいくのか再度トランザクションを実際に作ってテストする必要がありますね。

### signatureとpublic keyをPostされた側でのverify

    let signed_ut1 = SignedTransaction {time: unsignedtransaction.time, sender: unsignedtransaction.sender, receiver: unsignedtransaction.receiver, amount: unsignedtransaction.amount, signature: sig1.to_string()};
    println!("{:?}", signed_ut1);

    let public_key_decode = hex::decode(&signed_ut1.sender).unwrap();
    let public_key = p256::PublicKey::from_sec1_bytes(&public_key_decode).expect("import error");
    let verifying_key: VerifyingKey = public_key.into();

    let signature: Signature = signed_ut1.signature.parse::<Signature>().unwrap();

    let posted_transaction = UnsignedTransaction { time:signed_ut1.time, sender:signed_ut1.sender, receiver: signed_ut1.receiver, amount: signed_ut1.amount};
    let posted_serialized: String = serde_json::to_string(&posted_transaction).unwrap();

    assert!(verifying_key.verify(posted_serialized.as_bytes(), &signature).is_ok());

おおおおおおお、hexのpublic keyからちゃんと署名の検証ができてます。

自分が持っているblockのサイズと別のノードが持っているブロックサイズを比較して、相手の方が大きければ自分のブロックチェーンを更新する

    let path = "own_blocks.txt";
    let own_blocks = count_lines(path);
    println!("{}", own_blocks);

    let json_data = json();
    let deserialized = json!(**&json_data);
    let objs: Vec<Block> = serde_json::from_value(deserialized).unwrap();
    if objs.len() > own_blocks {
        let mut file = File::create("data/blocks.txt").expect("file not found.");
        for obj in &objs {
            let t = serde_json::to_string(&obj).unwrap();
            writeln!(file, "{}", t).expect("can not write.");
        }
    }
    println!("{}", objs.len());

OK、これを関数化して繋げる。

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);
}

うーん….

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—–

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

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ファイルとして保存したい。

templates/withdrawal.html

<form action="/sent" method="post" class="">
            <input type="hidden" name="time" id="time" value="">
            <input type="hidden" name="sender" value="{{address}}">
            <div class="mb-3">
                <label for="receiver" class="form-label">送付先アドレス</label>
                <input type="text" class="form-control" id="receiver" name="receiver" placeholder="送付先のアドレスを入力してください">
              </div>
              <div class="mb-3">
                <label for="amount" class="form-label">送付コイン量</label>
                <input type="text" class="form-control" id="amount" name="amount" placeholder="数量を半角数字で入力してください。e.g. 1000">
              </div>
              <input type="submit" value="送信" class="btn btn-primary"/>
        </form>

#[derive(Serialize, Deserialize, Debug)]
struct UnsignedTransaction {
    time: String,
    sender: String,
    receiver: String,
    amount: i32,
}
// 
async fn handle_sent(axum::Form(unsignedtransaction): axum::Form<UnsignedTransaction>)
    -> axum::response::Html<String> {

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

    let mut context = tera::Context::new();
    context.insert("time", &unsignedtransaction.time);
    context.insert("receiver", &unsignedtransaction.receiver);
    context.insert("amount", &unsignedtransaction.amount);

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

formのPOSTはできました。
このデータを受け取ったタイミングで、外部のIP(node)に合わせてPOSTしたい。