use std::collections::HashMap;

static M: HashMap<String, u64> = HashMap::new();

fn main() {
    println!("{:?}", M);
}

static M: u64 = num();

fn main() {
    println!("{:?}", M);
}

const fn num() -> u64 {
    10
}

// wallet/mod.rs
use anyhow::Result;

pub fn sign(msg: &str, account: &str) -> Result<String> {
    let sig = get_wallet(account)?
        .sign_hash(hash_message(msg))
        .to_string();

    Ok(sig)
}

let tx1 = Tx::builder()
    .from(TREASURY)
    .to(ALICE)
    .value(100)
    .nonce(next_nonce)
    .build()
    .sign();

// block.rs
impl BlockKV {
    pub fn take_block(&mut self) -> Block {
        mem::take(&mut self.value)
    }
}
// state.rs
let mut block_kv: BlockKV = serde_json::from_str(block_str)?;
let block = block_kv.take_block();
self.apply_block(block)?;

// balances: HashMap<String, u64>,
// account2nonce: HashMap<String, u64>,

// 确定key一定存在
*self.balances.get_mut(&tx.from).unwrap() -= tx.cost();
// key可能不存在
*self.balances.entry(tx.to.to_owned()).or_default() += tx.value;
*self.account2nonce.entry(tx.from.to_owned()).or_default() = tx.nonce;

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let vec = vec![1, 2, 3, 4, 5];
    let s1 = &arr[..2];
    let s2 = &vec[..2];
    // &[T] 和 &[T] 是否相等取决于长度和内容是否相等
    assert_eq!(s1, s2);
    // &[T] 可以和 Vec<T>/[T;n] 比较，也会看长度和内容
    assert_eq!(&arr[..], vec);
    assert_eq!(&vec[..], arr);
}

// state.rs
fn is_valid_hash(&self, hash: &H256) -> bool {
    // 不需要构造一个H256类型和hash对比
    // 只需要构造一个slice类型是[u8]的任意类型即可，然后比较两个slice
    let hash_prefix = vec![0u8; self.mining_difficulty];
    hash_prefix[..] == hash[..self.mining_difficulty]
}

// Iterator
fn main() {
    let result = vec![1, 2, 3, 4, 5]
        .iter()
        .map(|v| v * v)
        .filter(|v| *v < 16)
        .take(2)
        .collect::<Vec<_>>();

    println!("{:?}", result); // [1, 4]
}

// block.rs
pub fn block_reward(&self) -> u64 {
    let gas_reward: u64 = self.txs.iter().map(|tx| tx.gas_cost()).sum();
    gas_reward + BLOCK_REWORD
}