use chia_bls::Signature;
use chia_protocol::{Bytes32, CoinSpend};
use chia_wallet_sdk::signer::{AggSigConstants, RequiredSignature as SdkRequiredSignature};
use dig_wallet_backend::client::{derive_summary, LocalSigner, MasterKey};
use dig_wallet_backend::types::{
IdentityRef, Network, RequiredSignature, SignedBundle, UnsignedSpend, WalletId,
};
use crate::error::{AccountError, Result};
pub trait MoneySigner: Send + Sync {
fn sign_coin_spends(&self, coin_spends: &[CoinSpend]) -> Result<Signature>;
}
pub struct LocalMoneySigner {
inner: LocalSigner,
}
impl LocalMoneySigner {
pub(crate) fn new_canonical(
seed_bytes: Vec<u8>,
profile_ix: u32,
network: Network,
) -> Result<Self> {
let identity = IdentityRef::new(WalletId(0)).with_profile(profile_ix);
let master = MasterKey::from_seed_bytes(seed_bytes);
let inner = LocalSigner::new_canonical(identity, master, network)
.map_err(|e| AccountError::Spend(format!("cannot build money signer: {e}")))?;
Ok(Self { inner })
}
pub fn sign_unsigned(&self, unsigned: &UnsignedSpend) -> Result<SignedBundle> {
self.inner
.sign_unsigned(unsigned)
.map_err(|e| AccountError::Spend(format!("spend signing refused: {e}")))
}
fn required_signatures(&self, coin_spends: &[CoinSpend]) -> Result<Vec<RequiredSignature>> {
let mut allocator = clvmr::Allocator::new();
let constants = AggSigConstants::new(Bytes32::new(self.inner.agg_sig_me_extra_data()));
let extracted =
SdkRequiredSignature::from_coin_spends(&mut allocator, coin_spends, &constants)
.map_err(|e| {
AccountError::Spend(format!("required-signature extraction failed: {e:?}"))
})?;
let mut required = Vec::with_capacity(extracted.len());
for item in extracted {
match item {
SdkRequiredSignature::Bls(bls) => required.push(RequiredSignature {
public_key: bls.public_key,
message: bls.message(),
}),
SdkRequiredSignature::Secp(_) => {
return Err(AccountError::Spend(
"unexpected secp signature requirement in a wallet spend".into(),
))
}
}
}
Ok(required)
}
}
impl MoneySigner for LocalMoneySigner {
fn sign_coin_spends(&self, coin_spends: &[CoinSpend]) -> Result<Signature> {
let summary = derive_summary(coin_spends)
.map_err(|e| AccountError::Spend(format!("cannot derive spend summary: {e}")))?;
let required_signatures = self.required_signatures(coin_spends)?;
let unsigned = UnsignedSpend {
coin_spends: coin_spends.to_vec(),
required_signatures,
summary,
};
Ok(self.sign_unsigned(&unsigned)?.bundle.aggregated_signature)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::id::ProfileIx;
use crate::keys::wallet_key::WalletKey;
use chia_bls::{aggregate_verify, PublicKey};
use chia_protocol::{Bytes, Coin};
use chia_puzzle_types::Memos;
use chia_wallet_sdk::driver::{Spend, SpendContext, StandardLayer};
use chia_wallet_sdk::types::conditions::AggSigUnsafe;
use chia_wallet_sdk::types::{Condition, Conditions};
const SEED: [u8; 32] = [0x42; 32];
const PROFILE: u32 = 0;
fn money_key() -> WalletKey {
WalletKey::from_seed_at(&SEED, ProfileIx(PROFILE))
}
fn signer() -> LocalMoneySigner {
LocalMoneySigner::new_canonical(SEED.to_vec(), PROFILE, Network::Mainnet).unwrap()
}
fn wallet_coin(amount: u64, parent_seed: u8) -> Coin {
Coin::new(
Bytes32::new([parent_seed; 32]),
money_key().puzzle_hash(),
amount,
)
}
fn recipient_ph() -> Bytes32 {
Bytes32::new([7u8; 32])
}
fn legit_xch_send(send: u64, fee: u64, coin_amount: u64) -> Vec<CoinSpend> {
let mut ctx = SpendContext::new();
let recipient = recipient_ph();
let hint = ctx.hint(recipient).unwrap();
let change = coin_amount - send - fee;
let mut conditions = Conditions::new().create_coin(recipient, send, hint);
if change > 0 {
conditions = conditions.create_coin(money_key().puzzle_hash(), change, Memos::None);
}
if fee > 0 {
conditions = conditions.reserve_fee(fee);
}
StandardLayer::new(money_key().public_key())
.spend(&mut ctx, wallet_coin(coin_amount, 1), conditions)
.unwrap();
ctx.take()
}
#[test]
fn legit_standard_send_signs_and_verifies() {
let coin_spends = legit_xch_send(600, 10, 1_000);
let signature = signer().sign_coin_spends(&coin_spends).unwrap();
let mut allocator = clvmr::Allocator::new();
let constants = AggSigConstants::new(Bytes32::new(signer().inner.agg_sig_me_extra_data()));
let pairs: Vec<(PublicKey, Vec<u8>)> =
SdkRequiredSignature::from_coin_spends(&mut allocator, &coin_spends, &constants)
.unwrap()
.into_iter()
.map(|item| match item {
SdkRequiredSignature::Bls(bls) => (bls.public_key, bls.message()),
SdkRequiredSignature::Secp(_) => panic!("unexpected secp"),
})
.collect();
assert!(!pairs.is_empty(), "a real send requires a signature");
assert!(aggregate_verify(
&signature,
pairs.iter().map(|(pk, m)| (pk, m.as_slice())),
));
assert!(pairs.iter().any(|(pk, _)| *pk == money_key().public_key()));
}
#[test]
fn legit_cat_send_signs() {
use chia_wallet_sdk::driver::{Cat, CatSpend, SpendWithConditions};
let wallet_ph = money_key().puzzle_hash();
let cat = {
let mut issue_ctx = SpendContext::new();
let genesis = wallet_coin(1_000, 9);
let issue_hint = issue_ctx.hint(wallet_ph).unwrap();
let issue = Conditions::new().create_coin(wallet_ph, 1_000, issue_hint);
let (_, cats) =
Cat::issue_with_coin(&mut issue_ctx, genesis.coin_id(), 1_000, issue).unwrap();
cats[0]
};
let mut ctx = SpendContext::new();
let recipient = recipient_ph();
let send_hint = ctx.hint(recipient).unwrap();
let inner = StandardLayer::new(money_key().public_key())
.spend_with_conditions(
&mut ctx,
Conditions::new()
.create_coin(recipient, 600, send_hint)
.create_coin(wallet_ph, 400, Memos::None),
)
.unwrap();
Cat::spend_all(&mut ctx, &[CatSpend::new(cat, inner)]).unwrap();
let coin_spends = ctx.take();
let result = signer().sign_coin_spends(&coin_spends);
assert!(
result.is_ok(),
"a conserving CAT send from the wallet's own key must sign: {result:?}"
);
}
#[test]
fn engine_supplied_required_signatures_are_not_an_oracle() {
let coin_spends = legit_xch_send(600, 10, 1_000);
let summary = derive_summary(&coin_spends).unwrap();
let honest = signer().required_signatures(&coin_spends).unwrap();
let mut tampered = honest.clone();
tampered.push(RequiredSignature {
public_key: money_key().public_key(),
message: b"attacker-chosen-blank-check".to_vec(),
});
let unsigned = UnsignedSpend {
coin_spends,
required_signatures: tampered,
summary,
};
let err = signer().sign_unsigned(&unsigned).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)), "{err:?}");
}
#[test]
fn agg_sig_unsafe_requirement_is_refused() {
let mut ctx = SpendContext::new();
let recipient = recipient_ph();
let hint = ctx.hint(recipient).unwrap();
let conditions = Conditions::new()
.create_coin(recipient, 600, hint)
.create_coin(money_key().puzzle_hash(), 390, Memos::None)
.reserve_fee(10)
.with(Condition::AggSigUnsafe(AggSigUnsafe::new(
money_key().public_key(),
Bytes::from(b"raw-unbound-drain".to_vec()),
)));
StandardLayer::new(money_key().public_key())
.spend(&mut ctx, wallet_coin(1_000, 1), conditions)
.unwrap();
let err = signer().sign_coin_spends(&ctx.take()).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)), "{err:?}");
}
#[test]
fn solution_malleable_delegated_puzzle_is_refused() {
let mut ctx = SpendContext::new();
let malleable_puzzle = ctx.alloc(&1).unwrap();
let conditions =
Conditions::new().create_coin(money_key().puzzle_hash(), 1_000, Memos::None);
let solution = ctx.alloc(&conditions).unwrap();
let inner = Spend {
puzzle: malleable_puzzle,
solution,
};
let spend = StandardLayer::new(money_key().public_key())
.delegated_inner_spend(&mut ctx, inner)
.unwrap();
ctx.spend(wallet_coin(1_000, 1), spend).unwrap();
let err = signer().sign_coin_spends(&ctx.take()).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)), "{err:?}");
}
#[test]
fn empty_coin_spends_are_refused() {
let err = signer().sign_coin_spends(&[]).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)));
}
#[test]
fn signs_the_pinned_golden_money_key() {
const GOLDEN_SYNTHETIC_PK: [u8; 48] = [
0x88, 0x4c, 0xc9, 0xa2, 0xb2, 0x8a, 0x0a, 0xef, 0xe6, 0x2a, 0xb1, 0xcc, 0xc6, 0xc5,
0xe6, 0x38, 0xe4, 0x82, 0x24, 0xd1, 0xa1, 0x8a, 0x01, 0x52, 0x60, 0xb4, 0x05, 0x87,
0xe0, 0x7c, 0x91, 0x32, 0xe9, 0x29, 0xc3, 0xc3, 0xc1, 0x13, 0x54, 0x94, 0xcd, 0x11,
0xcc, 0x70, 0xb3, 0x6d, 0x7c, 0x34,
];
assert_eq!(money_key().public_key().to_bytes(), GOLDEN_SYNTHETIC_PK);
let coin_spends = legit_xch_send(600, 10, 1_000);
let signature = signer().sign_coin_spends(&coin_spends).unwrap();
let mut allocator = clvmr::Allocator::new();
let constants = AggSigConstants::new(Bytes32::new(signer().inner.agg_sig_me_extra_data()));
let golden_pk = PublicKey::from_bytes(&GOLDEN_SYNTHETIC_PK).unwrap();
let message =
SdkRequiredSignature::from_coin_spends(&mut allocator, &coin_spends, &constants)
.unwrap()
.into_iter()
.find_map(|item| match item {
SdkRequiredSignature::Bls(bls) if bls.public_key == golden_pk => {
Some(bls.message())
}
_ => None,
})
.expect("the spend must require the golden money key's signature");
assert!(chia_bls::verify(&signature, &golden_pk, &message));
}
}