Use WIF private keys and other improvements

Cargo.toml

@@ -36,7 +36,6 @@ secp256k1 = { version =  "0.22.1", features = ["rand", "rand-std", "global-conte
 serde = { version = "1.0.137", features = ["derive"] }
 serde_cbor = "0.11.2"
 serde_json = "1.0.81"
-sha2 = "0.10.2"
 tokio = { version = "1.17.0", features = ["rt-multi-thread"] }
 tower-http = { version = "0.3.3", features = ["cors"] }
 

src/main.rs

@@ -2,19 +2,18 @@
 
 use {
   crate::{
-    arguments::Arguments, bytes::Bytes, decode_bech32::decode_bech32, epoch::Epoch, height::Height,
-    index::Index, nft::Nft, options::Options, ordinal::Ordinal, sat_point::SatPoint,
-    subcommand::Subcommand,
+    arguments::Arguments, bytes::Bytes, epoch::Epoch, height::Height, index::Index, nft::Nft,
+    options::Options, ordinal::Ordinal, sat_point::SatPoint, subcommand::Subcommand,
   },
   anyhow::{anyhow, Context, Error},
   axum::{extract, http::StatusCode, response::IntoResponse, routing::get, Json, Router},
   axum_server::Handle,
   bech32::{FromBase32, ToBase32},
   bitcoin::{
-    blockdata::constants::COIN_VALUE, consensus::Decodable, consensus::Encodable, Address, Block,
-    BlockHash, Network, OutPoint, Transaction, Txid,
+    blockdata::constants::COIN_VALUE, consensus::Decodable, consensus::Encodable,
+    util::key::PrivateKey, Address, Block, BlockHash, Network, OutPoint, Transaction, Txid,
   },
-  bitcoin_hashes::{sha256d, Hash, HashEngine},
+  bitcoin_hashes::{sha256, sha256d, Hash, HashEngine},
   chrono::{DateTime, NaiveDateTime, Utc},
   clap::Parser,
   derive_more::{Display, FromStr},
@@ -55,7 +54,6 @@ use lmdb_database::{Database, WriteTransaction};
 
 mod arguments;
 mod bytes;
-mod decode_bech32;
 mod epoch;
 mod height;
 mod index;

src/nft.rs

@@ -11,16 +11,14 @@ pub(crate) struct Nft {
 
 #[derive(Serialize, Deserialize)]
 struct Metadata {
-  data_hash: sha256d::Hash,
+  data_hash: sha256::Hash,
   ordinal: Ordinal,
   public_key: XOnlyPublicKey,
 }
 
 impl Nft {
-  const HRP: &'static str = "nft";
-
   pub(crate) fn mint(ordinal: Ordinal, data: &[u8], signing_key_pair: KeyPair) -> Result<Self> {
-    let data_hash = sha256d::Hash::hash(data);
+    let data_hash = sha256::Hash::hash(data);
 
     let public_key = signing_key_pair.public_key();
 
@@ -49,43 +47,26 @@ impl Nft {
     &self.data
   }
 
-  pub(crate) fn encode(&self) -> String {
-    bech32::encode(
-      Self::HRP,
-      serde_cbor::to_vec(self).unwrap().to_base32(),
-      bech32::Variant::Bech32m,
-    )
-    .unwrap()
+  pub(crate) fn encode(&self) -> Vec<u8> {
+    serde_cbor::to_vec(self).unwrap()
   }
 
-  pub(crate) fn issuer(&self) -> String {
-    bech32::encode(
-      "pubkey",
-      self.metadata.public_key.serialize().to_base32(),
-      bech32::Variant::Bech32m,
-    )
-    .unwrap()
+  pub(crate) fn issuer(&self) -> XOnlyPublicKey {
+    self.metadata.public_key
   }
 
-  pub(crate) fn data_hash(&self) -> String {
-    bech32::encode(
-      "data",
-      self.metadata.data_hash.to_base32(),
-      bech32::Variant::Bech32m,
-    )
-    .unwrap()
+  pub(crate) fn data_hash(&self) -> sha256::Hash {
+    self.metadata.data_hash
   }
 
   pub(crate) fn ordinal(&self) -> Ordinal {
     self.metadata.ordinal
   }
 
-  pub(crate) fn verify(encoded: &str) -> Result<Self> {
-    let data = decode_bech32(encoded, Self::HRP)?;
-
-    let nft = serde_cbor::from_slice::<Nft>(&data)?;
+  pub(crate) fn verify(cbor: &[u8]) -> Result<Self> {
+    let nft = serde_cbor::from_slice::<Nft>(cbor)?;
 
-    let data_hash = sha256d::Hash::hash(&nft.data);
+    let data_hash = sha256::Hash::hash(&nft.data);
 
     if data_hash != nft.metadata.data_hash {
       return Err(anyhow!("NFT data hash does not match actual data_hash"));

src/subcommand/generate_private_key.rs

@@ -2,21 +2,14 @@ use super::*;
 
 pub(crate) fn run() -> Result {
   let mut rng = rand::thread_rng();
-  let secp = Secp256k1::new();
 
-  let secret_key = SecretKey::new(&mut rng);
-  let key_pair = KeyPair::from_secret_key(&secp, secret_key);
-  let public_key = key_pair.public_key();
-  let address = Address::p2tr(&secp, public_key, None, Network::Bitcoin);
+  let private_key = PrivateKey {
+    compressed: true,
+    network: Network::Bitcoin,
+    inner: SecretKey::new(&mut rng),
+  };
 
-  let private_key_bech32 = bech32::encode(
-    "privkey",
-    secret_key.as_ref().to_base32(),
-    bech32::Variant::Bech32m,
-  )
-  .unwrap();
-
-  println!("{} {}", private_key_bech32, address);
+  println!("{}", private_key.to_wif());
 
   Ok(())
 }

src/subcommand/mint.rs

@@ -6,7 +6,7 @@ pub(crate) struct Mint {
   data_path: PathBuf,
   #[clap(long, help = "Assign NFT to <ORDINAL>")]
   ordinal: Ordinal,
-  #[clap(long, help = "Sign NFT with bech32m-formatted <SIGNING_KEY>")]
+  #[clap(long, help = "Sign NFT with WIF-formatted <SIGNING_KEY>")]
   signing_key: String,
   #[clap(long, help = "Write signed NFT metadata to <OUTPUT_PATH>")]
   output_path: PathBuf,
@@ -17,12 +17,12 @@ impl Mint {
     let data = fs::read(&self.data_path)
       .with_context(|| format!("Failed to read data from {}", self.data_path.display()))?;
 
-    let secret_key = SecretKey::from_slice(&decode_bech32(&self.signing_key, "privkey")?)?;
+    let private_key = PrivateKey::from_wif(&self.signing_key)?;
 
     let nft = Nft::mint(
       self.ordinal,
       &data,
-      KeyPair::from_secret_key(&Secp256k1::new(), secret_key),
+      KeyPair::from_secret_key(&Secp256k1::new(), private_key.inner),
     )?;
 
     fs::write(&self.output_path, nft.encode())

src/subcommand/verify.rs

@@ -8,7 +8,7 @@ pub(crate) struct Verify {
 
 impl Verify {
   pub(crate) fn run(self) -> Result {
-    let encoded = fs::read_to_string(&self.input_path)
+    let encoded = fs::read(&self.input_path)
       .with_context(|| format!("Failed to read NFT from `{}`", self.input_path.display()))?;
 
     let nft = Nft::verify(&encoded)

tests/nft.rs

@@ -9,7 +9,7 @@ fn mint_and_verify() -> Result {
       "--ordinal",
       "0",
       "--signing-key",
-      "privkey13jcd573rjnnx8nauuc26tec4qwxv7qnyd59f3nwyef65qyp9598s9p8hy6",
+      "KysB4eR1DjAmbf1qkiznwgd4xPy8yj66gHF4dBJmhFraoL1gjqZd",
       "--data-path",
       "data.txt",
       "--output-path",
@@ -22,8 +22,8 @@ fn mint_and_verify() -> Result {
     .expected_stderr(
       "NFT is valid!
 Ordinal: 0
-Issuer: pubkey1ny8pdtw4ftxgn0p42cw00mvkjqlks4mk6ju5w9xcwatfhrh3at6qkrsmkm
-Data hash: data1c7k73r785g2f3f49uhpctc0k30kcy2mj4f3uf2dy3gpvy3nwu20q97shse
+Issuer: 1b7bb1348ae7a273e55644a920ecf4e5b7d8a5d0966c649e720601e73c737eb7
+Data hash: 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae
 ",
     )
     .expected_stdout("foo")