sequenceDiagram
    participant bot_A
    participant bot_B
    participant TxPool
    participant Chain
    Note over bot_A,Chain: ボット間でのnonce競合のケース    
    bot_A->>TxPool: Tx(nonce:10, gas:20Gwei)
    bot_B->>TxPool: Tx(nonce:10, gas:22Gwei)
    Note over TxPool: 同じnonceで高いガス価格のTxを優先
    TxPool->>Chain: Tx from bot_B (nonce:10)
    Chain-->>bot_B: success
    TxPool-->>bot_A: failed (nonce has already been used)

# 常に最新バージョンを使うのは悪意あるコードが混入する可能性あるので避けてる
# 最近もsolana/web3.jsのnpmパッケージに攻撃者が悪意のあるコードを含んだバージョンあったし
# pip install bip-utils==2.9.0 pandas==1.5.3 tqdm==4.66.4 web3==6.6.1
# versionは適当だがweb3は関数名が変わるので注意

import pandas as pd
from datetime import datetime
from bip_utils import Bip39MnemonicGenerator, Bip39MnemonicValidator, Bip39WordsNum
from tqdm.auto import tqdm
from web3 import Web3

N_GENERATE = 10000

web3 = Web3()
web3.eth.account.enable_unaudited_hdwallet_features()

list_wallet = []
for _ in tqdm(range(N_GENERATE)):
    mnemonic = Bip39MnemonicGenerator().FromWordsNumber(Bip39WordsNum.WORDS_NUM_12).ToStr()
    account = web3.eth.account.from_mnemonic(mnemonic)
    list_wallet.append({'address': account.address, 'private_key': account._private_key.hex(), 'mnemonic': mnemonic})

df_wallet = pd.DataFrame(list_wallet, columns=['address', 'private_key', 'mnemonic'])
df_wallet.to_csv(f'wallet_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', index=False)

# pip install bip-utils==2.9.0 pandas==1.5.3 tqdm==4.66.4 web3==6.6.1 joblib==1.3.0
import pandas as pd
from bip_utils import Bip39MnemonicGenerator, Bip39MnemonicValidator, Bip39WordsNum
from datetime import datetime
from tqdm.auto import tqdm
from web3 import Web3
from joblib import Parallel, delayed

N_GENERATE = 10000

def generate_wallet():
    web3 = Web3()
    web3.eth.account.enable_unaudited_hdwallet_features()
    mnemonic = Bip39MnemonicGenerator().FromWordsNumber(Bip39WordsNum.WORDS_NUM_12).ToStr()
    account = web3.eth.account.from_mnemonic(mnemonic)
    return {'address': account.address, 'private_key': account._private_key.hex(), 'mnemonic': mnemonic}

list_wallet = Parallel(n_jobs=-2)(delayed(generate_wallet)() for _ in tqdm(range(N_GENERATE)))

df_wallet = pd.DataFrame(list_wallet, columns=['address', 'private_key', 'mnemonic'])
df_wallet.to_csv(f'wallet_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', index=False)

# ./Cargo.toml

[package]
name = "generate_wallets"
version = "0.1.0"
edition = "2021"

[dependencies]
bip39 = "2.0"
ethereum-types = "0.14"
hex = "0.4"
indicatif = "0.17"
rayon = "1.7"
rand = "0.8"
secp256k1 = { version = "0.27", features = ["rand"] }
serde = { version = "1.0", features = ["derive"] }
tiny-keccak = { version = "2.0", features = ["keccak"] }
csv = "1.2"
num_cpus = "1.16"
tiny-hderive = "0.3"

[profile.release]
lto = true
codegen-units = 1
panic = "abort"

// ./src/main.rs
// cargo run --release

use bip39::{Mnemonic, Language};
use ethereum_types::H160;
use hex;
use indicatif::{ProgressBar, ProgressStyle};
use rayon::prelude::*;
use secp256k1::{SecretKey, PublicKey, Secp256k1};
use serde::Serialize;
use std::fs::File;
use std::time::SystemTime;
use csv::Writer;
use tiny_keccak::{Hasher, Keccak};
use std::sync::Arc;
use rand::rngs::OsRng;
use rand::Rng;
use tiny_hderive::bip32::ExtendedPrivKey;
use std::io::BufWriter;

#[derive(Serialize)]
struct Wallet {
    address: String,
    private_key: String,
    mnemonic: String,
}

fn keccak256(input: &[u8]) -> [u8; 32] {
    let mut hasher = Keccak::v256();
    let mut output = [0u8; 32];
    hasher.update(input);
    hasher.finalize(&mut output);
    output
}

fn to_checksum_address(addr: &str) -> String {
    let addr_lower = addr.to_lowercase();
    let mut hasher = Keccak::v256();
    hasher.update(addr_lower.as_bytes());
    let mut hash = [0u8; 32];
    hasher.finalize(&mut hash);
    let hash_hex = hex::encode(hash);

    let mut checksum_addr = String::with_capacity(2 + addr_lower.len());
    checksum_addr.push_str("0x");

    for (i, c) in addr_lower.chars().enumerate() {
        let val = u8::from_str_radix(&hash_hex[i..i+1], 16).unwrap();
        if val >= 8 {
            checksum_addr.push(c.to_ascii_uppercase());
        } else {
            checksum_addr.push(c);
        }
    }

    checksum_addr
}

fn generate_wallet(secp: &Secp256k1<secp256k1::All>) -> Wallet {
    let mut rng = OsRng;
    let mut entropy = [0u8; 16];
    rng.fill(&mut entropy);

    let mnemonic = Mnemonic::from_entropy_in(Language::English, &entropy).unwrap();

    let seed = mnemonic.to_seed("");

    let xprv = ExtendedPrivKey::derive(seed.as_ref(), "m/44'/60'/0'/0/0")
        .expect("Failed to derive xprv");
    let secret_key = SecretKey::from_slice(&xprv.secret()).expect("Invalid secret key slice");

    let public_key = PublicKey::from_secret_key(secp, &secret_key);
    let public_key_bytes = public_key.serialize_uncompressed();
    let keccak = keccak256(&public_key_bytes[1..]);
    let address = H160::from_slice(&keccak[12..]);

    let words = mnemonic.words();
    let mut phrase = String::with_capacity(12 * 8);
    if let Some(first) = words.clone().next() {
        phrase.push_str(first);
    }
    for w in words.skip(1) {
        phrase.push(' ');
        phrase.push_str(w);
    }

    let address_hex = hex::encode(address.as_bytes());
    let checksum_address = to_checksum_address(&address_hex);

    Wallet {
        address: checksum_address,
        private_key: hex::encode(secret_key.as_ref()),
        mnemonic: phrase,
    }
}

fn main() {
    const N_GENERATE: usize = 100000000; // 1億ウォレット欲しいんじゃい!!

    println!("Generating {} wallets...", N_GENERATE);

    rayon::ThreadPoolBuilder::new()
        .num_threads(num_cpus::get() - 1) // コア数-1
        .build_global()
        .unwrap();

    let pb = ProgressBar::new(N_GENERATE as u64);
    pb.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {pos}/{len} ({per_sec}, {eta})")
            .unwrap()
            .progress_chars("#>-")
    );

    let secp = Arc::new(Secp256k1::new());

    let wallets: Vec<Wallet> = (0..N_GENERATE)
        .into_par_iter()
        .map(|_| {
            let wallet = generate_wallet(&secp);
            pb.inc(1);
            wallet
        })
        .collect();

    pb.finish_with_message("Generation completed");

    let timestamp = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .unwrap()
        .as_secs();
    let filename = format!("wallet_{}.csv", timestamp);

    let file = File::create(&filename).unwrap();
    let mut writer = Writer::from_writer(BufWriter::new(file));

    for wallet in wallets {
        writer.serialize(wallet).unwrap();
    }
    writer.flush().unwrap();

    println!("Wallets saved to {}", filename);
    println!("Run with `cargo run --release` for best performance.");
}