use chia_bls::{master_to_wallet_unhardened, PublicKey, SecretKey};
use chia_protocol::Bytes32;
use chia_puzzle_types::{standard::StandardArgs, DeriveSynthetic};
use chia_wallet_sdk::utils::Address;
use crate::error::{AccountError, Result};
use crate::id::ProfileIx;
pub struct WalletKey {
#[allow(dead_code)]
synthetic: SecretKey,
synthetic_pk: PublicKey,
}
impl WalletKey {
pub fn from_seed(seed: &[u8]) -> WalletKey {
Self::from_seed_at(seed, ProfileIx::ROOT)
}
pub fn from_seed_at(seed: &[u8], ix: ProfileIx) -> WalletKey {
let master = SecretKey::from_seed(seed);
let synthetic = master_to_wallet_unhardened(&master, ix.0).derive_synthetic();
let synthetic_pk = synthetic.public_key();
WalletKey {
synthetic,
synthetic_pk,
}
}
#[allow(dead_code)] pub(crate) fn secret_key(&self) -> &SecretKey {
&self.synthetic
}
pub fn public_key(&self) -> PublicKey {
self.synthetic_pk
}
pub fn puzzle_hash(&self) -> Bytes32 {
StandardArgs::curry_tree_hash(self.public_key()).into()
}
pub fn address(&self) -> Result<String> {
Address::new(self.puzzle_hash(), "xch".to_string())
.encode()
.map_err(|e| AccountError::Keystore(format!("address encode: {e}")))
}
}
#[cfg(test)]
mod tests {
use super::*;
const SEED: [u8; 32] = [0x42; 32];
const fn h<const N: usize>(s: &str) -> [u8; N] {
let bytes = s.as_bytes();
assert!(bytes.len() == N * 2, "hex length mismatch");
let mut out = [0u8; N];
let mut i = 0;
while i < N {
out[i] = nibble(bytes[i * 2]) << 4 | nibble(bytes[i * 2 + 1]);
i += 1;
}
out
}
const fn nibble(c: u8) -> u8 {
match c {
b'0'..=b'9' => c - b'0',
b'a'..=b'f' => c - b'a' + 10,
_ => panic!("bad hex nibble"),
}
}
const GOLDEN_SYNTHETIC_PK: [u8; 48] = h(
"884cc9a2b28a0aefe62ab1ccc6c5e638e48224d1a18a015260b40587e07c9132e929c3c3c1135494cd11cc70b36d7c34",
);
const GOLDEN_PUZZLE_HASH: [u8; 32] =
h("e05ec4f5685b878461988e9f26d3cb88556942d3c716c176d72eeeddfd9994a3");
const GOLDEN_ADDRESS: &str = "xch1up0vfatgtwrcgcvc360jd57t3p2kjskncutvzakh9mhdmlvejj3shn8wln";
#[test]
fn matches_the_pinned_synthetic_golden_vector() {
let key = WalletKey::from_seed(&SEED);
assert_eq!(
key.public_key().to_bytes(),
GOLDEN_SYNTHETIC_PK,
"synthetic public key drifted from the frozen pre-cutover dig-app contract"
);
assert_eq!(key.puzzle_hash().to_bytes(), GOLDEN_PUZZLE_HASH);
assert_eq!(key.address().unwrap(), GOLDEN_ADDRESS);
}
#[test]
fn dropping_synthetic_breaks_the_golden() {
let master = SecretKey::from_seed(&SEED);
let non_synthetic_pk = master_to_wallet_unhardened(&master, 0).public_key();
assert_ne!(
non_synthetic_pk.to_bytes(),
GOLDEN_SYNTHETIC_PK,
"the golden must distinguish the synthetic key from the raw unhardened key"
);
}
#[test]
fn from_seed_is_the_root_index() {
assert_eq!(
WalletKey::from_seed(&SEED).public_key(),
WalletKey::from_seed_at(&SEED, ProfileIx::ROOT).public_key(),
);
}
#[test]
fn distinct_indices_derive_distinct_keys() {
let k0 = WalletKey::from_seed_at(&SEED, ProfileIx::ROOT);
let k1 = WalletKey::from_seed_at(&SEED, ProfileIx(1));
assert_ne!(k0.public_key(), k1.public_key());
assert_ne!(k0.secret_key(), k1.secret_key());
}
#[test]
fn public_key_corresponds_to_secret_key() {
let key = WalletKey::from_seed_at(&SEED, ProfileIx(3));
assert_eq!(key.public_key(), key.secret_key().public_key());
}
#[test]
fn derivation_is_deterministic() {
assert_eq!(
WalletKey::from_seed(&SEED).public_key(),
WalletKey::from_seed(&SEED).public_key(),
);
}
#[test]
fn address_is_a_bech32m_xch_string() {
assert!(WalletKey::from_seed(&SEED)
.address()
.unwrap()
.starts_with("xch1"));
}
}