Update byron tests Update address tests + fix for byron address serialization (old code would ommit bootstrap in addr attributes contrary to the stated byron.cddl) Fix doc-tests in crypto lib
}
}
}
/*
#[cfg(test)]
mod tests {
use crate::{byron::AddressContent, ledger::common::hash::ScriptHashNamespace};
use crate::{byron::AddressContent, transaction::NativeScript};
use super::*;
use cml_core::serialization::ToBytes;
use cml_crypto::*;
#[test]
fn base_serialize_consistency() {
let base = BaseAddress::new(
5,
StakeCredential::from_keyhash(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::from_scripthash(ScriptHash::from([42; ScriptHash::BYTE_COUNT])),
StakeCredential::new_pub_key(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::new_script(ScriptHash::from([42; ScriptHash::BYTE_COUNT])),
);
let addr = base.to_address();
let addr2 = Address::from_bytes(addr.to_bytes()).unwrap();
assert_eq!(addr.to_bytes(), addr2.to_bytes());
let addr2 = Address::from_cbor_bytes(&addr.to_cbor_bytes()).unwrap();
assert_eq!(addr.to_cbor_bytes(), addr2.to_cbor_bytes());
}
#[test]
fn ptr_serialize_consistency() {
let ptr = PointerAddress::new(
25,
StakeCredential::from_keyhash(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::new_pub_key(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
Pointer::new(2354556573, 127, 0),
);
let addr = ptr.to_address();
let addr2 = Address::from_bytes(addr.to_bytes()).unwrap();
assert_eq!(addr.to_bytes(), addr2.to_bytes());
let addr2 = Address::from_cbor_bytes(&addr.to_cbor_bytes()).unwrap();
assert_eq!(addr.to_cbor_bytes(), addr2.to_cbor_bytes());
}
#[test]
fn enterprise_serialize_consistency() {
let enterprise = EnterpriseAddress::new(
64,
StakeCredential::from_keyhash(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::new_pub_key(Ed25519KeyHash::from([23; Ed25519KeyHash::BYTE_COUNT])),
);
let addr = enterprise.to_address();
let addr2 = Address::from_bytes(addr.to_bytes()).unwrap();
assert_eq!(addr.to_bytes(), addr2.to_bytes());
let addr2 = Address::from_cbor_bytes(&addr.to_cbor_bytes()).unwrap();
assert_eq!(addr.to_cbor_bytes(), addr2.to_cbor_bytes());
}
#[test]
fn reward_serialize_consistency() {
let reward = RewardAddress::new(
9,
StakeCredential::from_scripthash(ScriptHash::from([127; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::new_script(ScriptHash::from([127; Ed25519KeyHash::BYTE_COUNT])),
);
let addr = reward.to_address();
let addr2 = Address::from_bytes(addr.to_bytes()).unwrap();
assert_eq!(addr.to_bytes(), addr2.to_bytes());
let addr2 = Address::from_cbor_bytes(&addr.to_cbor_bytes()).unwrap();
assert_eq!(addr.to_cbor_bytes(), addr2.to_cbor_bytes());
}
#[test]
fn address_header_matching() {
let reward = RewardAddress::new(
0b1001,
StakeCredential::from_scripthash(ScriptHash::from([127; Ed25519KeyHash::BYTE_COUNT])),
StakeCredential::new_script(ScriptHash::from([127; Ed25519KeyHash::BYTE_COUNT])),
)
.to_address();
assert_eq!(reward.header(), 0b1111_1001);
.derive(2)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let stake_cred = StakeCredential::from_keyhash(stake.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let stake_cred = StakeCredential::new_pub_key(stake.to_raw_key().hash());
let addr_net_0 = BaseAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 =
EnterpriseAddress::new(NetworkInfo::testnet().network_id(), spend_cred.clone())
.to_address();
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 = PointerAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
.derive(2)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(&spend.to_raw_key().hash());
let stake_cred = StakeCredential::from_keyhash(&stake.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let stake_cred = StakeCredential::new_pub_key(stake.to_raw_key().hash());
let addr_net_0 = BaseAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 =
EnterpriseAddress::new(NetworkInfo::testnet().network_id(), spend_cred.clone())
.to_address();
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 = PointerAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
.derive(0)
.to_public();
let byron_addr =
AddressContent::icarus_from_key(&byron_key, NetworkInfo::mainnet().protocol_magic());
AddressContent::icarus_from_key(byron_key, NetworkInfo::mainnet().protocol_magic());
assert_eq!(
byron_addr.to_address().to_base58(),
"Ae2tdPwUPEZHtBmjZBF4YpMkK9tMSPTE2ADEZTPN97saNkhG78TvXdp3GDk"
assert_eq!(byron_addr.network_id().unwrap(), 0b0001);
// round-trip from generic address type and back
let generic_addr = Address::from_bytes(byron_addr.to_address().to_bytes()).unwrap();
let byron_addr_2 = ByronAddress::from_address(generic_addr).unwrap();
let generic_addr = Address::from_raw_bytes(&byron_addr.to_address().to_bytes()).unwrap();
let byron_addr_2 = ByronAddress::from_address(&generic_addr).unwrap();
assert_eq!(
byron_addr.to_address().to_base58(),
byron_addr_2.to_base58()
.derive(2)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let stake_cred = StakeCredential::from_keyhash(stake.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let stake_cred = StakeCredential::new_pub_key(stake.to_raw_key().hash());
let addr_net_0 = BaseAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 =
EnterpriseAddress::new(NetworkInfo::testnet().network_id(), spend_cred.clone())
.to_address();
.derive(0)
.derive(0)
.to_public();
let spend_cred = StakeCredential::from_keyhash(spend.to_raw_key().hash());
let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
let addr_net_0 = PointerAddress::new(
NetworkInfo::testnet().network_id(),
spend_cred.clone(),
&Pointer::new(1, 2, 3),
Pointer::new(1, 2, 3),
)
.to_address();
assert_eq!(
let addr_net_3 = PointerAddress::new(
NetworkInfo::mainnet().network_id(),
spend_cred,
&self,
serializer: &'se mut Serializer<W>,
) -> cbor_event::Result<&'se mut Serializer<W>> {
// NOTE: This was manually modified *slightly*
// The direct cddl-codegen code will always include the stake distribution
// but the old byron code seems to only put it in when it's not bootstrap.
serializer.write_map(cbor_event::Len::Len(
match &self.stake_distribution {
Some(_) => 1,
None => 0,
Some(StakeDistribution::SingleKey(_)) => 1,
_ => 0,
} + match &self.derivation_path {
Some(_) => 1,
None => 0,
None => 0,
},
))?;
if let Some(field) = &self.stake_distribution {
if let Some(StakeDistribution::SingleKey(_)) = &self.stake_distribution {
serializer.write_unsigned_integer(0u64)?;
let mut stake_distribution_inner_se = Serializer::new_vec();
field.serialize(&mut stake_distribution_inner_se)?;
self.stake_distribution.as_ref().unwrap().serialize(&mut stake_distribution_inner_se)?;
let stake_distribution_bytes = stake_distribution_inner_se.finalize();
serializer.write_bytes(&stake_distribution_bytes)?;
}
}
// icarus-style address (Ae2)
pub fn icarus_from_key(key: Bip32PublicKey, protocol_magic: u32) -> AddressContent {
pub fn icarus_from_key(key: Bip32PublicKey, protocol_magic: ProtocolMagic) -> AddressContent {
// need to ensure we use None for mainnet since Byron-era addresses omitted the network id
let filtered_protocol_magic = if protocol_magic == NetworkInfo::mainnet().protocol_magic().0 { None } else { Some(ProtocolMagic(protocol_magic)) };
let filtered_protocol_magic = if protocol_magic == NetworkInfo::mainnet().protocol_magic() { None } else { Some(protocol_magic) };
AddressContent::new_simple( key, filtered_protocol_magic)
}
)
}
/*
#[cfg(test)]
mod tests {
use cml_core::serialization::ToBytes;
use cml_crypto::{
Bip32PublicKey,
chain_crypto::{self, Ed25519Bip32}
chain_crypto::{self, Ed25519Bip32}, Deserialize
};
use crate::genesis::network_info::NetworkInfo;
use super::{ByronAddress};
fn assert_same_address(address: ByronAddress, xpub: chain_crypto::PublicKey<Ed25519Bip32>) {
assert_eq!(
address.address_content().identical_with_pubkey(&Bip32PublicKey(xpub.clone())),
true,
assert!(
address.content.identical_with_pubkey(xpub.clone().into()),
"expected public key {} to match address {}",
xpub,
address,
#[test]
fn test_vector_1() {
let address: ByronAddress = "DdzFFzCqrhsrcTVhLygT24QwTnNqQqQ8mZrq5jykUzMveU26sxaH529kMpo7VhPrt5pwW3dXeB2k3EEvKcNBRmzCfcQ7dTkyGzTs658C".parse().unwrap();
println!("{}", hex::encode(address.addr()));
let address: ByronAddress = "DdzFFzCqrhsrcTVhLygT24QwTnNqQqQ8mZrq5jykUzMveU26sxaH529kMpo7VhPrt5pwW3dXeB2k3EEvKcNBRmzCfcQ7dTkyGzTs658C".parse().unwrap();
let public_key = chain_crypto::PublicKey::<Ed25519Bip32>::from_binary(&[
0x6a, 0x50, 0x96, 0x89, 0xc6, 0x53, 0x17, 0x58, 0x65, 0x98, 0x5a, 0xd1, 0xe0, 0xeb,
0x5f, 0xf9, 0xad, 0xa6, 0x99, 0x7a, 0xa4, 0x03, 0xe6, 0x48, 0x61, 0x4b, 0x3b, 0x78,
fn byron_magic_parsing() {
// mainnet address w/ protocol magic omitted
let addr = ByronAddress::from_base58("Ae2tdPwUPEZ4YjgvykNpoFeYUxoyhNj2kg8KfKWN2FizsSpLUPv68MpTVDo").unwrap();
println!("{}", hex::encode(addr.addr()));
let content = addr.address_content();
assert_eq!(content.byron_protocol_magic(), NetworkInfo::mainnet().protocol_magic());
assert_eq!(content.network_id().unwrap(), NetworkInfo::mainnet().network_id());
assert_eq!(addr.content.byron_protocol_magic(), NetworkInfo::mainnet().protocol_magic());
assert_eq!(addr.content.network_id().unwrap(), NetworkInfo::mainnet().network_id());
// original Byron testnet address
let addr = ByronAddress::from_base58("2cWKMJemoBaipzQe9BArYdo2iPUfJQdZAjm4iCzDA1AfNxJSTgm9FZQTmFCYhKkeYrede").unwrap();
let content = addr.address_content();
assert_eq!(content.byron_protocol_magic(), NetworkInfo::testnet().protocol_magic());
assert_eq!(content.network_id().unwrap(), NetworkInfo::testnet().network_id());
assert_eq!(addr.content.byron_protocol_magic(), NetworkInfo::testnet().protocol_magic());
assert_eq!(addr.content.network_id().unwrap(), NetworkInfo::testnet().network_id());
}
#[test]
fn round_trip() {
// mainnet address
let start = "DdzFFzCqrhsqTG4t3uq5UBqFrxhxGVM6bvF4q1QcZXqUpizFddEEip7dx5rbife2s9o2fRU3hVKhRp4higog7As8z42s4AMw6Pcu8vL4";
let addr = ByronAddress::from_base58(start).unwrap();
let content = addr.address_content();
let end = content.to_address().to_base58();
let end = addr.content.to_address().to_base58();
assert_eq!(start, end);
// mainnet address w/ protocol magic omitted
let start = "Ae2tdPwUPEZ4YjgvykNpoFeYUxoyhNj2kg8KfKWN2FizsSpLUPv68MpTVDo";
let addr = ByronAddress::from_base58(start).unwrap();
let content = addr.address_content();
let end = content.to_address().to_base58();
let end = addr.content.to_address().to_base58();
assert_eq!(start, end);
// original Byron testnet address
let start = "2cWKMJemoBaipzQe9BArYdo2iPUfJQdZAjm4iCzDA1AfNxJSTgm9FZQTmFCYhKkeYrede";
let addr = ByronAddress::from_base58(start).unwrap();
let content = addr.address_content();
let end = content.to_address().to_base58();
let end = addr.content.to_address().to_base58();
assert_eq!(start, end);
// testnet genesis address
let start = "37btjrVyb4KEg6anTcJ9E4EAvYtNV9xXL6LNpA15YLhgvm9zJ1D2jwme574HikZ36rKdTwaUmpEicCoL1bDw4CtH5PNcFnTRGQNaFd5ai6Wvo6CZsi";
let addr = ByronAddress::from_base58(start).unwrap();
let content = addr.address_content();
let end = content.to_address().to_base58();
let end = addr.content.to_address().to_base58();
assert_eq!(start, end);
}
assert!(ByronAddress::is_valid("Ae2tdPwUPEZ3MHKkpT5Bpj549vrRH7nBqYjNXnCV8G2Bc2YxNcGHEa8ykDp"));
let byron_addr = ByronAddress::from_base58("Ae2tdPwUPEZ3MHKkpT5Bpj549vrRH7nBqYjNXnCV8G2Bc2YxNcGHEa8ykDp").unwrap();
assert_eq!(byron_addr.to_base58(), "Ae2tdPwUPEZ3MHKkpT5Bpj549vrRH7nBqYjNXnCV8G2Bc2YxNcGHEa8ykDp");
let byron_addr2 = ByronAddress::from_bytes(byron_addr.to_bytes()).unwrap();
let byron_addr2 = ByronAddress::from_cbor_bytes(&byron_addr.to_bytes()).unwrap();
assert_eq!(byron_addr2.to_base58(), "Ae2tdPwUPEZ3MHKkpT5Bpj549vrRH7nBqYjNXnCV8G2Bc2YxNcGHEa8ykDp");
}
}
*/
/// Get private key from its bech32 representation
/// ```rust
/// PrivateKey::from_bech32('ed25519_sk1ahfetf02qwwg4dkq7mgp4a25lx5vh9920cr5wnxmpzz9906qvm8qwvlts0');
/// use cml_crypto::PrivateKey;
/// let key = PrivateKey::from_bech32("ed25519_sk1ahfetf02qwwg4dkq7mgp4a25lx5vh9920cr5wnxmpzz9906qvm8qwvlts0").unwrap();
/// ```
/// For an extended 25519 key
/// ```rust
/// PrivateKey::from_bech32('ed25519e_sk1gqwl4szuwwh6d0yk3nsqcc6xxc3fpvjlevgwvt60df59v8zd8f8prazt8ln3lmz096ux3xvhhvm3ca9wj2yctdh3pnw0szrma07rt5gl748fp');
/// use cml_crypto::PrivateKey;
/// let key = PrivateKey::from_bech32("ed25519e_sk1gqwl4szuwwh6d0yk3nsqcc6xxc3fpvjlevgwvt60df59v8zd8f8prazt8ln3lmz096ux3xvhhvm3ca9wj2yctdh3pnw0szrma07rt5gl748fp").unwrap();
/// ```
pub fn from_bech32(bech32_str: &str) -> Result<PrivateKey, CryptoError> {
chain_crypto::SecretKey::try_from_bech32_str(&bech32_str)
/// Get public key from its bech32 representation
/// Example:
/// ```rust
/// let pkey = PublicKey::from_bech32('ed25519_pk1dgaagyh470y66p899txcl3r0jaeaxu6yd7z2dxyk55qcycdml8gszkxze2')?;
/// use cml_crypto::PublicKey;
/// let key = PublicKey::from_bech32("ed25519_pk1dgaagyh470y66p899txcl3r0jaeaxu6yd7z2dxyk55qcycdml8gszkxze2").unwrap();
/// ```
pub fn from_bech32(bech32_str: &str) -> Result<PublicKey, CryptoError> {
chain_crypto::PublicKey::try_from_bech32_str(&bech32_str)
//impl_hash_type!(KESSignature, 448);
impl_hash_type!(NonceHash, 32);
#[derive(Clone)]
pub struct LegacyDaedalusPrivateKey(chain_crypto::SecretKey<chain_crypto::LegacyDaedalus>);
impl LegacyDaedalusPrivateKey {
Signed-off-by: Pat Losoponkul <[email protected]>
Co-authored-by: Alexey Kuleshevich <[email protected]>
Corresponding to [this PR](https://github.com/input-output-hk/cardano-ledger/pull/3756).
Signed-off-by: Pat Losoponkul <[email protected]>
Feat/lw 7973 cip95 sign tx
Signed-off-by: Juliano Lazzarotto <[email protected]>
Co-authored-by: Alexey Kuleshevich <[email protected]>
This PR makes integration test suite work without requiring the environment variable "SHELLEY_TEST_DATA"; On top of it, the naming was made consistent: **Before:** "SHELLEY_DATA_PATH", "cardano-node-shelley", "cluster setup dir" etc. **After:** - the directory is renamed to `lib/local-cluster/test/data/cluster-configs` - the env var is renamed to "LOCAL_CLUSTER_CONFIGS" - the `Config`'s data type accessor function is `cfgClusterConfigs`
Signed-off-by: banklesss <[email protected]>
