diff --git a/common/src/address.rs b/common/src/address.rs index 225a148e..837a3bd8 100644 --- a/common/src/address.rs +++ b/common/src/address.rs @@ -4,12 +4,10 @@ use crate::cip19::{VarIntDecoder, VarIntEncoder}; use crate::types::{KeyHash, ScriptHash}; -use crate::Credential; +use crate::{Credential, NetworkId}; use anyhow::{anyhow, bail, Result}; use serde_with::{hex::Hex, serde_as}; -use std::borrow::Borrow; use std::fmt::{Display, Formatter}; -use std::hash::{Hash, Hasher}; /// a Byron-era address #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] @@ -28,6 +26,15 @@ pub enum AddressNetwork { Test, } +impl From for AddressNetwork { + fn from(network: NetworkId) -> Self { + match network { + NetworkId::Mainnet => Self::Main, + NetworkId::Testnet => Self::Test, + } + } +} + impl Default for AddressNetwork { fn default() -> Self { Self::Main @@ -201,7 +208,7 @@ impl StakeAddressPayload { } /// A stake address -#[derive(Debug, Clone, Eq, serde::Serialize, serde::Deserialize)] +#[derive(Debug, Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)] pub struct StakeAddress { /// Network id pub network: AddressNetwork, @@ -211,7 +218,7 @@ pub struct StakeAddress { } impl StakeAddress { - pub fn new(network: AddressNetwork, payload: StakeAddressPayload) -> Self { + pub fn new(payload: StakeAddressPayload, network: AddressNetwork) -> Self { StakeAddress { network, payload } } @@ -305,26 +312,6 @@ impl Display for StakeAddress { } } -impl Hash for StakeAddress { - fn hash(&self, state: &mut H) { - self.network.hash(state); - std::mem::discriminant(&self.payload).hash(state); - self.get_hash().hash(state); - } -} - -impl Borrow<[u8]> for StakeAddress { - fn borrow(&self) -> &[u8] { - self.get_hash() - } -} - -impl PartialEq for StakeAddress { - fn eq(&self, other: &Self) -> bool { - self.network == other.network && self.payload == other.payload - } -} - impl minicbor::Encode for StakeAddress { fn encode( &self, diff --git a/common/src/queries/governance.rs b/common/src/queries/governance.rs index be6b1240..678b35a9 100644 --- a/common/src/queries/governance.rs +++ b/common/src/queries/governance.rs @@ -1,6 +1,6 @@ use std::collections::HashMap; -use crate::{Anchor, Credential, DRepCredential, GovActionId, Lovelace, ProposalProcedure, TxHash, Vote, Voter, VotingProcedure}; +use crate::{Anchor, DRepCredential, GovActionId, Lovelace, ProposalProcedure, StakeAddress, TxHash, Vote, Voter, VotingProcedure}; pub const DEFAULT_DREPS_QUERY_TOPIC: (&str, &str) = ("drep-state-query-topic", "cardano.query.dreps"); @@ -58,12 +58,12 @@ pub struct DRepInfo { #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct DRepInfoWithDelegators { pub info: DRepInfo, - pub delegators: Vec, + pub delegators: Vec, } #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct DRepDelegatorAddresses { - pub addresses: Vec, + pub addresses: Vec, } #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] diff --git a/common/src/stake_addresses.rs b/common/src/stake_addresses.rs index 945aac4b..2189fc03 100644 --- a/common/src/stake_addresses.rs +++ b/common/src/stake_addresses.rs @@ -528,10 +528,10 @@ mod tests { fn create_stake_address(hash: &[u8]) -> StakeAddress { StakeAddress::new( - AddressNetwork::Main, StakeAddressPayload::StakeKeyHash( hash.to_vec().try_into().expect("Invalid hash length"), ), + AddressNetwork::Main, ) } diff --git a/common/src/types.rs b/common/src/types.rs index c0cb1aa6..c1708627 100644 --- a/common/src/types.rs +++ b/common/src/types.rs @@ -6,7 +6,6 @@ use crate::{ address::{Address, ShelleyAddress, StakeAddress}, protocol_params, rational_number::RationalNumber, - AddressNetwork, StakeAddressPayload, }; use anyhow::{anyhow, bail, Error, Result}; use bech32::{Bech32, Hrp}; @@ -26,6 +25,16 @@ pub enum NetworkId { Mainnet, } +impl From for NetworkId { + fn from(s: String) -> Self { + match s.as_str() { + "testnet" => NetworkId::Testnet, + "mainnet" => NetworkId::Mainnet, + _ => NetworkId::Mainnet, + } + } +} + /// Protocol era #[derive( Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize, @@ -613,20 +622,6 @@ impl Credential { pub type StakeCredential = Credential; -impl StakeCredential { - pub fn to_stake_address(&self, network: Option) -> StakeAddress { - let payload = match self { - StakeCredential::AddrKeyHash(hash) => StakeAddressPayload::StakeKeyHash( - hash.clone().try_into().expect("Invalid hash length"), - ), - StakeCredential::ScriptHash(hash) => StakeAddressPayload::ScriptHash( - hash.clone().try_into().expect("Invalid hash length"), - ), - }; - StakeAddress::new(network.unwrap_or(AddressNetwork::Main), payload) - } -} - /// Relay single host address #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize, Eq, PartialEq)] pub struct SingleHostAddr { @@ -739,7 +734,7 @@ pub struct PoolRegistration { /// Pool owners by their key hash // #[serde_as(as = "Vec")] #[n(6)] - pub pool_owners: Vec, + pub pool_owners: Vec, // Relays #[n(7)] @@ -824,8 +819,8 @@ pub struct PoolEpochState { /// Stake delegation data #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct StakeDelegation { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// Pool ID to delegate to pub operator: KeyHash, @@ -877,7 +872,7 @@ pub enum InstantaneousRewardSource { /// Target of a MIR #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub enum InstantaneousRewardTarget { - StakeCredentials(Vec<(StakeCredential, i64)>), + StakeAddresses(Vec<(StakeAddress, i64)>), OtherAccountingPot(u64), } @@ -894,8 +889,8 @@ pub struct MoveInstantaneousReward { /// Register stake (Conway version) = 'reg_cert' #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct Registration { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// Deposit paid pub deposit: Lovelace, @@ -904,8 +899,8 @@ pub struct Registration { /// Deregister stake (Conway version) = 'unreg_cert' #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct Deregistration { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// Deposit to be refunded pub refund: Lovelace, @@ -930,8 +925,8 @@ pub enum DRepChoice { /// Vote delegation (simple, existing registration) = vote_deleg_cert #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct VoteDelegation { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, // DRep choice pub drep: DRepChoice, @@ -940,8 +935,8 @@ pub struct VoteDelegation { /// Stake+vote delegation (to SPO and DRep) = stake_vote_deleg_cert #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct StakeAndVoteDelegation { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// Pool pub operator: KeyHash, @@ -953,8 +948,8 @@ pub struct StakeAndVoteDelegation { /// Stake delegation to SPO + registration = stake_reg_deleg_cert #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct StakeRegistrationAndDelegation { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// Pool pub operator: KeyHash, @@ -966,8 +961,8 @@ pub struct StakeRegistrationAndDelegation { /// Vote delegation to DRep + registration = vote_reg_deleg_cert #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct StakeRegistrationAndVoteDelegation { - /// Stake credential - pub credential: StakeCredential, + /// Stake address + pub stake_address: StakeAddress, /// DRep choice pub drep: DRepChoice, @@ -982,7 +977,7 @@ pub struct StakeRegistrationAndVoteDelegation { #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct StakeRegistrationAndStakeAndVoteDelegation { /// Stake credential - pub credential: StakeCredential, + pub stake_address: StakeAddress, /// Pool pub operator: KeyHash, @@ -1660,8 +1655,8 @@ pub struct GovernanceOutcome { } #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] -pub struct StakeCredentialWithPos { - pub stake_credential: StakeCredential, +pub struct StakeAddressWithPos { + pub stake_address: StakeAddress, pub tx_index: u64, pub cert_index: u64, } @@ -1673,10 +1668,10 @@ pub enum TxCertificate { None(()), /// Stake registration - StakeRegistration(StakeCredentialWithPos), + StakeRegistration(StakeAddressWithPos), /// Stake de-registration - StakeDeregistration(StakeCredential), + StakeDeregistration(StakeAddress), /// Stake Delegation to a pool StakeDelegation(StakeDelegation), diff --git a/modules/accounts_state/src/rewards.rs b/modules/accounts_state/src/rewards.rs index 4b9bd8dd..06528a86 100644 --- a/modules/accounts_state/src/rewards.rs +++ b/modules/accounts_state/src/rewards.rs @@ -335,7 +335,6 @@ fn calculate_spo_rewards( if !to_delegators.is_zero() { let total_stake = BigDecimal::from(spo.total_stake); for (delegator_stake_address, stake) in &spo.delegators { - let delegator_credential = delegator_stake_address.get_credential(); let proportion = BigDecimal::from(stake) / &total_stake; // and hence how much of the total reward they get @@ -346,7 +345,7 @@ fn calculate_spo_rewards( delegator_stake_address); // Pool owners don't get member rewards (seems unfair!) - if spo.pool_owners.contains(&delegator_credential) { + if spo.pool_owners.contains(&delegator_stake_address) { debug!( "Skipping pool owner reward account {}, losing {to_pay}", delegator_stake_address diff --git a/modules/accounts_state/src/snapshot.rs b/modules/accounts_state/src/snapshot.rs index c4720d3c..81e09f46 100644 --- a/modules/accounts_state/src/snapshot.rs +++ b/modules/accounts_state/src/snapshot.rs @@ -1,7 +1,7 @@ //! Acropolis AccountsState: snapshot for rewards calculations use crate::state::{Pots, RegistrationChange}; -use acropolis_common::{stake_addresses::StakeAddressMap, Credential, KeyHash, Lovelace, PoolRegistration, Ratio, StakeAddress}; +use acropolis_common::{stake_addresses::StakeAddressMap, KeyHash, Lovelace, PoolRegistration, Ratio, StakeAddress}; use imbl::OrdMap; use std::collections::HashMap; use std::sync::Arc; @@ -35,7 +35,7 @@ pub struct SnapshotSPO { pub two_previous_reward_account_is_registered: bool, /// Pool owners - pub pool_owners: Vec, + pub pool_owners: Vec, } /// Snapshot of stake distribution taken at the end of an particular epoch @@ -159,18 +159,18 @@ impl Snapshot { pub fn get_stake_delegated_to_spo_by_addresses( &self, spo: &KeyHash, - addresses: &[Credential], + addresses: &[StakeAddress], ) -> Lovelace { let Some(snapshot_spo) = self.spos.get(spo) else { return 0; }; - let addr_set: std::collections::HashSet<_> = addresses.iter().collect(); + let address_set: std::collections::HashSet<_> = addresses.iter().collect(); snapshot_spo .delegators .iter() - .filter_map(|(addr, amount)| { - if addr_set.contains(&addr.get_credential()) { + .filter_map(|(address, amount)| { + if address_set.contains(&address) { Some(*amount) } else { None @@ -321,9 +321,9 @@ mod tests { // Extract key hashes from stake addresses for the API call let addresses = vec![ - addr2.get_credential(), - addr3.get_credential(), - addr4.get_credential(), + addr2, + addr3, + addr4, ]; let result = snapshot.get_stake_delegated_to_spo_by_addresses(&spo1, &addresses); assert_eq!(result, 500); @@ -347,7 +347,7 @@ mod tests { ); // Extract key hash from stake address for the API call - let addresses = vec![addr_x.get_credential()]; + let addresses = vec![addr_x]; let result = snapshot.get_stake_delegated_to_spo_by_addresses(&spo1, &addresses); assert_eq!(result, 0); } diff --git a/modules/accounts_state/src/state.rs b/modules/accounts_state/src/state.rs index b4a9dad3..5dbb0278 100644 --- a/modules/accounts_state/src/state.rs +++ b/modules/accounts_state/src/state.rs @@ -14,8 +14,8 @@ use acropolis_common::{ protocol_params::ProtocolParams, stake_addresses::{StakeAddressMap, StakeAddressState}, BlockInfo, DRepChoice, DRepCredential, DelegatedStake, InstantaneousRewardSource, - InstantaneousRewardTarget, KeyHash, Lovelace, MoveInstantaneousReward, PoolLiveStakeInfo, - PoolRegistration, Pot, SPORewards, StakeAddress, StakeCredential, StakeRewardDelta, + InstantaneousRewardTarget, KeyHash, Lovelace, MoveInstantaneousReward, + PoolLiveStakeInfo, PoolRegistration, Pot, SPORewards, StakeAddress, StakeRewardDelta, TxCertificate, }; use anyhow::Result; @@ -546,12 +546,10 @@ impl State { }; match &mir.target { - InstantaneousRewardTarget::StakeCredentials(deltas) => { + InstantaneousRewardTarget::StakeAddresses(deltas) => { // Transfer to (in theory also from) stake addresses from (to) a pot let mut total_value: u64 = 0; - for (credential, value) in deltas.iter() { - let stake_address = credential.to_stake_address(None); // Need to convert credential to address - + for (stake_address, value) in deltas.iter() { // Get old stake address state, or create one let mut stake_addresses = self.stake_addresses.lock().unwrap(); let sas = stake_addresses.entry(stake_address.clone()).or_default(); @@ -791,10 +789,7 @@ impl State { } /// Register a stake address, with a specified deposit if known - fn register_stake_address(&mut self, credential: &StakeCredential, deposit: Option) { - // TODO: Handle network - let stake_address = credential.to_stake_address(None); - + fn register_stake_address(&mut self, stake_address: &StakeAddress, deposit: Option) { // Stake addresses can be registered after being used in UTXOs let mut stake_addresses = self.stake_addresses.lock().unwrap(); if stake_addresses.register_stake_address(&stake_address) { @@ -816,16 +811,13 @@ impl State { // Add to registration changes self.current_epoch_registration_changes.lock().unwrap().push(RegistrationChange { - address: stake_address, + address: stake_address.clone(), kind: RegistrationChangeKind::Registered, }); } /// Deregister a stake address, with specified refund if known - fn deregister_stake_address(&mut self, credential: &StakeCredential, refund: Option) { - // TODO: Handle network - let stake_address = credential.to_stake_address(None); - + fn deregister_stake_address(&mut self, stake_address: &StakeAddress, refund: Option) { // Check if it existed let mut stake_addresses = self.stake_addresses.lock().unwrap(); if stake_addresses.deregister_stake_address(&stake_address) { @@ -848,7 +840,7 @@ impl State { // Add to registration changes self.current_epoch_registration_changes.lock().unwrap().push(RegistrationChange { - address: stake_address, + address: stake_address.clone(), kind: RegistrationChangeKind::Deregistered, }); } @@ -859,9 +851,7 @@ impl State { } /// Record a stake delegation - fn record_stake_delegation(&mut self, credential: &StakeCredential, spo: &KeyHash) { - // TODO: Handle network - let stake_address = credential.to_stake_address(None); + fn record_stake_delegation(&mut self, stake_address: &StakeAddress, spo: &KeyHash) { let mut stake_addresses = self.stake_addresses.lock().unwrap(); stake_addresses.record_stake_delegation(&stake_address, spo); } @@ -873,9 +863,7 @@ impl State { } /// record a drep delegation - fn record_drep_delegation(&mut self, credential: &StakeCredential, drep: &DRepChoice) { - // TODO: Handle network - let stake_address = credential.to_stake_address(None); + fn record_drep_delegation(&mut self, stake_address: &StakeAddress, drep: &DRepChoice) { let mut stake_addresses = self.stake_addresses.lock().unwrap(); stake_addresses.record_drep_delegation(&stake_address, drep); } @@ -885,12 +873,12 @@ impl State { // Handle certificates for tx_cert in tx_certs_msg.certificates.iter() { match tx_cert { - TxCertificate::StakeRegistration(sc_with_pos) => { - self.register_stake_address(&sc_with_pos.stake_credential, None); + TxCertificate::StakeRegistration(stake_address_with_pos) => { + self.register_stake_address(&stake_address_with_pos.stake_address, None); } - TxCertificate::StakeDeregistration(sc) => { - self.deregister_stake_address(&sc, None); + TxCertificate::StakeDeregistration(stake_address) => { + self.deregister_stake_address(&stake_address, None); } TxCertificate::MoveInstantaneousReward(mir) => { @@ -898,40 +886,49 @@ impl State { } TxCertificate::Registration(reg) => { - self.register_stake_address(®.credential, Some(reg.deposit)); + self.register_stake_address(®.stake_address, Some(reg.deposit)); } TxCertificate::Deregistration(dreg) => { - self.deregister_stake_address(&dreg.credential, Some(dreg.refund)); + self.deregister_stake_address(&dreg.stake_address, Some(dreg.refund)); } TxCertificate::StakeDelegation(delegation) => { - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); } TxCertificate::VoteDelegation(delegation) => { - self.record_drep_delegation(&delegation.credential, &delegation.drep); + self.record_drep_delegation(&delegation.stake_address, &delegation.drep); } TxCertificate::StakeAndVoteDelegation(delegation) => { - self.record_stake_delegation(&delegation.credential, &delegation.operator); - self.record_drep_delegation(&delegation.credential, &delegation.drep); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); + self.record_drep_delegation(&delegation.stake_address, &delegation.drep); } TxCertificate::StakeRegistrationAndDelegation(delegation) => { - self.register_stake_address(&delegation.credential, Some(delegation.deposit)); - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.register_stake_address( + &delegation.stake_address, + Some(delegation.deposit), + ); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); } TxCertificate::StakeRegistrationAndVoteDelegation(delegation) => { - self.register_stake_address(&delegation.credential, Some(delegation.deposit)); - self.record_drep_delegation(&delegation.credential, &delegation.drep); + self.register_stake_address( + &delegation.stake_address, + Some(delegation.deposit), + ); + self.record_drep_delegation(&delegation.stake_address, &delegation.drep); } TxCertificate::StakeRegistrationAndStakeAndVoteDelegation(delegation) => { - self.register_stake_address(&delegation.credential, Some(delegation.deposit)); - self.record_stake_delegation(&delegation.credential, &delegation.operator); - self.record_drep_delegation(&delegation.credential, &delegation.drep); + self.register_stake_address( + &delegation.stake_address, + Some(delegation.deposit), + ); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); + self.record_drep_delegation(&delegation.stake_address, &delegation.drep); } _ => (), @@ -991,8 +988,8 @@ mod tests { use super::*; use acropolis_common::{ protocol_params::ConwayParams, rational_number::RationalNumber, AddressNetwork, Anchor, - Committee, Constitution, CostModel, Credential, DRepVotingThresholds, PoolVotingThresholds, - Pot, PotDelta, Ratio, Registration, StakeAddress, StakeAddressDelta, StakeAddressPayload, + Committee, Constitution, CostModel, DRepVotingThresholds, PoolVotingThresholds, Pot, + PotDelta, Ratio, Registration, StakeAddress, StakeAddressDelta, StakeAddressPayload, StakeAndVoteDelegation, StakeRegistrationAndStakeAndVoteDelegation, StakeRegistrationAndVoteDelegation, VoteDelegation, Withdrawal, }; @@ -1007,10 +1004,6 @@ mod tests { } } - fn create_stake_credential(hash: &[u8]) -> StakeCredential { - StakeCredential::AddrKeyHash(hash.to_vec()) - } - const STAKE_KEY_HASH: [u8; 3] = [0x99, 0x0f, 0x00]; const DREP_HASH: [u8; 4] = [0xca, 0xfe, 0xd0, 0x0d]; @@ -1020,7 +1013,7 @@ mod tests { let stake_address = create_address(&STAKE_KEY_HASH); // Register first - state.register_stake_address(&StakeCredential::AddrKeyHash(STAKE_KEY_HASH.to_vec()), None); + state.register_stake_address(&stake_address, None); { let stake_addresses = state.stake_addresses.lock().unwrap(); @@ -1107,14 +1100,12 @@ mod tests { // Delegate let addr1 = create_address(&[0x11]); - let cred1 = Credential::AddrKeyHash(addr1.get_hash().to_vec()); - state.register_stake_address(&cred1, None); - state.record_stake_delegation(&cred1, &spo1); + state.register_stake_address(&addr1, None); + state.record_stake_delegation(&addr1, &spo1); let addr2 = create_address(&[0x12]); - let cred2 = Credential::AddrKeyHash(addr2.get_hash().to_vec()); - state.register_stake_address(&cred2, None); - state.record_stake_delegation(&cred2, &spo2); + state.register_stake_address(&addr2, None); + state.record_stake_delegation(&addr2, &spo2); // Put some value in let msg1 = StakeAddressDeltasMessage { @@ -1220,13 +1211,12 @@ mod tests { fn mir_transfers_to_stake_addresses() { let mut state = State::default(); let stake_address = create_address(&STAKE_KEY_HASH); - let stake_credential = create_stake_credential(stake_address.get_hash()); // Bootstrap with some in reserves state.pots.reserves = 100; // Set up one stake address - state.register_stake_address(&stake_credential, None); + state.register_stake_address(&stake_address, None); let msg = StakeAddressDeltasMessage { deltas: vec![StakeAddressDelta { @@ -1247,9 +1237,9 @@ mod tests { // Send in a MIR reserves->{47,-5}->stake let mir = MoveInstantaneousReward { source: InstantaneousRewardSource::Reserves, - target: InstantaneousRewardTarget::StakeCredentials(vec![ - (stake_credential.clone(), 47), - (stake_credential, -5), + target: InstantaneousRewardTarget::StakeAddresses(vec![ + (stake_address.clone(), 47), + (stake_address.clone(), -5), ]), }; @@ -1269,13 +1259,12 @@ mod tests { fn withdrawal_transfers_from_stake_addresses() { let mut state = State::default(); let stake_address = create_address(&STAKE_KEY_HASH); - let stake_credential = create_stake_credential(stake_address.get_hash()); // Bootstrap with some in reserves state.pots.reserves = 100; // Set up one stake address - state.register_stake_address(&stake_credential, None); + state.register_stake_address(&stake_address, None); let msg = StakeAddressDeltasMessage { deltas: vec![StakeAddressDelta { address: stake_address.clone(), @@ -1297,7 +1286,7 @@ mod tests { // Send in a MIR reserves->42->stake let mir = MoveInstantaneousReward { source: InstantaneousRewardSource::Reserves, - target: InstantaneousRewardTarget::StakeCredentials(vec![(stake_credential, 42)]), + target: InstantaneousRewardTarget::StakeAddresses(vec![(stake_address.clone(), 42)]), }; state.handle_mir(&mir).unwrap(); @@ -1375,38 +1364,33 @@ mod tests { let spo3 = create_address(&[0x03]); let spo4 = create_address(&[0x04]); - let spo1_credential = create_stake_credential(spo1.get_hash()); - let spo2_credential = create_stake_credential(spo2.get_hash()); - let spo3_credential = create_stake_credential(spo3.get_hash()); - let spo4_credential = create_stake_credential(spo4.get_hash()); - let certificates = vec![ // register the first two SPOs separately from their delegation TxCertificate::Registration(Registration { - credential: spo1_credential.clone(), + stake_address: spo1.clone(), deposit: 1, }), TxCertificate::Registration(Registration { - credential: spo2_credential.clone(), + stake_address: spo2.clone(), deposit: 1, }), TxCertificate::VoteDelegation(VoteDelegation { - credential: spo1_credential.clone(), + stake_address: spo1.clone(), drep: DRepChoice::Key(DREP_HASH.to_vec()), }), TxCertificate::StakeAndVoteDelegation(StakeAndVoteDelegation { - credential: spo2_credential.clone(), + stake_address: spo2.clone(), operator: spo1.get_hash().to_vec(), drep: DRepChoice::Script(DREP_HASH.to_vec()), }), TxCertificate::StakeRegistrationAndVoteDelegation(StakeRegistrationAndVoteDelegation { - credential: spo3_credential.clone(), + stake_address: spo3.clone(), drep: DRepChoice::Abstain, deposit: 1, }), TxCertificate::StakeRegistrationAndStakeAndVoteDelegation( StakeRegistrationAndStakeAndVoteDelegation { - credential: spo4_credential, + stake_address: spo4.clone(), operator: spo1.get_hash().to_vec(), drep: DRepChoice::NoConfidence, deposit: 1, diff --git a/modules/drep_state/src/drep_state.rs b/modules/drep_state/src/drep_state.rs index eaaaf208..ccb97901 100644 --- a/modules/drep_state/src/drep_state.rs +++ b/modules/drep_state/src/drep_state.rs @@ -141,6 +141,7 @@ impl DRepState { context.clone(), &tx_certs_msg.certificates, block_info.epoch, + ) .await .inspect_err(|e| error!("Certificates handling error: {e:#}")) diff --git a/modules/drep_state/src/state.rs b/modules/drep_state/src/state.rs index 89fe9a5c..a97ded4e 100644 --- a/modules/drep_state/src/state.rs +++ b/modules/drep_state/src/state.rs @@ -1,10 +1,15 @@ //! Acropolis DRepState: State storage -use acropolis_common::{messages::{Message, StateQuery, StateQueryResponse}, queries::{ - accounts::{AccountsStateQuery, AccountsStateQueryResponse, DEFAULT_ACCOUNTS_QUERY_TOPIC}, - get_query_topic, - governance::{DRepActionUpdate, DRepUpdateEvent, VoteRecord}, -}, Anchor, Credential, DRepChoice, DRepCredential, KeyHash, Lovelace, StakeAddress, StakeCredential, TxCertificate, TxHash, Voter, VotingProcedures}; +use acropolis_common::{ + messages::{Message, StateQuery, StateQueryResponse}, + queries::{ + accounts::{AccountsStateQuery, AccountsStateQueryResponse, DEFAULT_ACCOUNTS_QUERY_TOPIC}, + get_query_topic, + governance::{DRepActionUpdate, DRepUpdateEvent, VoteRecord}, + }, + Anchor, DRepChoice, DRepCredential, KeyHash, Lovelace, + StakeAddress, TxCertificate, TxHash, Voter, VotingProcedures, +}; use anyhow::{anyhow, Result}; use caryatid_sdk::Context; use serde_with::serde_as; @@ -33,7 +38,7 @@ pub struct HistoricalDRepState { // - StakeAndVoteDelegation // - StakeRegistrationAndVoteDelegation // - StakeRegistrationAndStakeAndVoteDelegation - pub delegators: Option>, + pub delegators: Option>, // Populated from voting_procedures in GovernanceProceduresMessage pub votes: Option>, @@ -147,7 +152,7 @@ impl State { pub fn get_drep_delegators( &self, credential: &DRepCredential, - ) -> Result>, &'static str> { + ) -> Result>, &'static str> { let hist = self .historical_dreps .as_ref() @@ -223,8 +228,10 @@ impl State { for tx_cert in tx_certs { if store_delegators { - if let Some((cred, drep)) = Self::extract_delegation_fields(tx_cert) { - batched_delegators.push((cred, drep)); + if let Some((delegator, drep)) = + Self::extract_delegation_fields(tx_cert) + { + batched_delegators.push((delegator, drep)); continue; } } @@ -467,16 +474,11 @@ impl State { async fn update_delegators( &mut self, context: &Arc>, - delegators: Vec<(&StakeCredential, &DRepChoice)>, + delegators: Vec<(StakeAddress, &DRepChoice)>, ) -> Result<()> { - let stake_keys: Vec = delegators.iter().map(|(sc, _)| sc.get_hash()).collect(); - // TODO: USE NETWORK ID - let stake_addresses: Vec = delegators.iter().map(|(k, _) | k.to_stake_address(None) ).collect(); - let stake_key_to_input: HashMap = delegators - .iter() - .zip(&stake_keys) - .map(|((sc, drep), key)| (key.clone(), (*sc, *drep))) - .collect(); + let stake_addresses = delegators.iter().map(|(addr, _)| (addr).clone()).collect(); + let stake_key_to_input: HashMap = + delegators.iter().map(|(addr, drep)| (addr.get_credential().get_hash(), (addr, *drep))).collect(); let msg = Arc::new(Message::StateQuery(StateQuery::Accounts( AccountsStateQuery::GetAccountsDrepDelegationsMap { stake_addresses }, @@ -535,13 +537,21 @@ impl State { Ok(()) } - fn extract_delegation_fields(cert: &TxCertificate) -> Option<(&StakeCredential, &DRepChoice)> { + fn extract_delegation_fields( + cert: &TxCertificate, + ) -> Option<(StakeAddress, &DRepChoice)> { match cert { - TxCertificate::VoteDelegation(d) => Some((&d.credential, &d.drep)), - TxCertificate::StakeAndVoteDelegation(d) => Some((&d.credential, &d.drep)), - TxCertificate::StakeRegistrationAndVoteDelegation(d) => Some((&d.credential, &d.drep)), + TxCertificate::VoteDelegation(d) => { + Some((d.stake_address.clone(), &d.drep)) + } + TxCertificate::StakeAndVoteDelegation(d) => { + Some((d.stake_address.clone(), &d.drep)) + } + TxCertificate::StakeRegistrationAndVoteDelegation(d) => { + Some((d.stake_address.clone(), &d.drep)) + } TxCertificate::StakeRegistrationAndStakeAndVoteDelegation(d) => { - Some((&d.credential, &d.drep)) + Some((d.stake_address.clone(), &d.drep)) } _ => None, } diff --git a/modules/rest_blockfrost/src/handlers/governance.rs b/modules/rest_blockfrost/src/handlers/governance.rs index 0563ddc8..13beff49 100644 --- a/modules/rest_blockfrost/src/handlers/governance.rs +++ b/modules/rest_blockfrost/src/handlers/governance.rs @@ -4,11 +4,15 @@ use crate::types::{ DRepInfoREST, DRepMetadataREST, DRepUpdateREST, DRepVoteREST, DRepsListREST, ProposalVoteREST, VoterRoleREST, }; -use acropolis_common::{messages::{Message, RESTResponse, StateQuery, StateQueryResponse}, queries::{ - accounts::{AccountsStateQuery, AccountsStateQueryResponse}, - governance::{GovernanceStateQuery, GovernanceStateQueryResponse}, -}, Credential, GovActionId, StakeAddress, TxHash, Voter}; -use anyhow::Result; +use acropolis_common::{ + messages::{Message, RESTResponse, StateQuery, StateQueryResponse}, + queries::{ + accounts::{AccountsStateQuery, AccountsStateQueryResponse}, + governance::{GovernanceStateQuery, GovernanceStateQueryResponse}, + }, + Credential, GovActionId, KeyHash, TxHash, Voter, +}; +use anyhow::{anyhow, Result}; use caryatid_sdk::Context; use reqwest::Client; use serde_json::Value; @@ -95,8 +99,7 @@ pub async fn handle_single_drep_blockfrost( )) => { let active = !response.info.retired && !response.info.expired; - let stake_addresses = - response.delegators.iter().map(|addr| addr.to_stake_address(None)).collect(); + let stake_addresses = response.delegators.clone(); let sum_msg = Arc::new(Message::StateQuery(StateQuery::Accounts( AccountsStateQuery::GetAccountsBalancesSum { stake_addresses }, @@ -188,29 +191,32 @@ pub async fn handle_drep_delegators_blockfrost( Message::StateQueryResponse(StateQueryResponse::Governance( GovernanceStateQueryResponse::DRepDelegators(delegators), )) => { - let mut stake_addresses: Vec = Vec::new(); - let mut stake_key_to_bech32 = HashMap::new(); - - for addr in &delegators.addresses { - let bech32 = match addr.to_stake_bech32() { - Ok(b) => b, - Err(_) => { - return Ok(RESTResponse::with_text( - 500, - "Internal error: failed to encode stake address", - )); - } - }; - - let hash = addr.get_hash(); - // TODO: NETWORK ID - let stake_address = addr.to_stake_address(None); - stake_addresses.push(stake_address.clone()); - stake_key_to_bech32.insert(hash, bech32); - } + let stake_key_to_bech32: HashMap = match delegators + .addresses + .iter() + .map(|addr| { + let credential = addr.get_credential(); + let bech32 = credential + .to_stake_bech32() + .map_err(|_| anyhow!("Failed to encode stake address"))?; + let key_hash = credential.get_hash(); + Ok((key_hash, bech32)) + }) + .collect::>>() + { + Ok(map) => map, + Err(e) => { + return Ok(RESTResponse::with_text( + 500, + &format!("Internal error: {e}"), + )); + } + }; let msg = Arc::new(Message::StateQuery(StateQuery::Accounts( - AccountsStateQuery::GetAccountsUtxoValuesMap { stake_addresses }, + AccountsStateQuery::GetAccountsUtxoValuesMap { + stake_addresses: delegators.addresses.clone(), + }, ))); let raw_msg = diff --git a/modules/rest_blockfrost/src/handlers/pools.rs b/modules/rest_blockfrost/src/handlers/pools.rs index eaa27403..9ae26994 100644 --- a/modules/rest_blockfrost/src/handlers/pools.rs +++ b/modules/rest_blockfrost/src/handlers/pools.rs @@ -664,11 +664,7 @@ async fn handle_pools_spo_blockfrost( // Query owner accounts balance sum from accounts_state let live_pledge_msg = Arc::new(Message::StateQuery(StateQuery::Accounts( AccountsStateQuery::GetAccountsUtxoValuesSum { - stake_addresses: pool_info - .pool_owners - .iter() - .map(|owner| owner.to_stake_address(None)) - .collect(), + stake_addresses: pool_info.pool_owners.clone(), }, ))); @@ -703,7 +699,7 @@ async fn handle_pools_spo_blockfrost( let pool_owners = pool_info .pool_owners .iter() - .map(|owner| owner.to_stake_bech32()) + .map(|owner| owner.get_credential().to_stake_bech32()) .collect::, _>>(); let Ok(pool_owners) = pool_owners else { return Ok(RESTResponse::with_text(404, "Invalid Pool Owners")); diff --git a/modules/spo_state/src/state.rs b/modules/spo_state/src/state.rs index 059ff70b..115e9dda 100644 --- a/modules/spo_state/src/state.rs +++ b/modules/spo_state/src/state.rs @@ -1,9 +1,19 @@ //! Acropolis SPOState: State storage -use acropolis_common::{crypto::keyhash_224, ledger_state::SPOState, messages::{ - CardanoMessage, Message, SPOStateMessage, StakeAddressDeltasMessage, - StakeRewardDeltasMessage, TxCertificatesMessage, WithdrawalsMessage, -}, params::TECHNICAL_PARAMETER_POOL_RETIRE_MAX_EPOCH, queries::governance::VoteRecord, stake_addresses::StakeAddressMap, BlockInfo, KeyHash, PoolMetadata, PoolRegistration, PoolRegistrationWithPos, PoolRetirement, PoolRetirementWithPos, PoolUpdateEvent, Relay, StakeAddress, StakeCredential, TxCertificate, TxHash, Voter, VotingProcedures}; +use acropolis_common::{ + crypto::keyhash_224, + ledger_state::SPOState, + messages::{ + CardanoMessage, Message, SPOStateMessage, StakeAddressDeltasMessage, + StakeRewardDeltasMessage, TxCertificatesMessage, WithdrawalsMessage, + }, + params::TECHNICAL_PARAMETER_POOL_RETIRE_MAX_EPOCH, + queries::governance::VoteRecord, + stake_addresses::StakeAddressMap, + BlockInfo, KeyHash, PoolMetadata, PoolRegistration, PoolRegistrationWithPos, PoolRetirement, + PoolRetirementWithPos, PoolUpdateEvent, Relay, StakeAddress, TxCertificate, TxHash, Voter, + VotingProcedures, +}; use anyhow::Result; use imbl::HashMap; use std::sync::{Arc, Mutex}; @@ -427,21 +437,21 @@ impl State { } } - fn register_stake_address(&mut self, credential: &StakeCredential) { + fn register_stake_address(&mut self, stake_address: &StakeAddress) { let Some(stake_addresses) = self.stake_addresses.as_ref() else { return; }; let mut stake_addresses = stake_addresses.lock().unwrap(); - stake_addresses.register_stake_address(&credential.to_stake_address(None)); + stake_addresses.register_stake_address(stake_address); } - fn deregister_stake_address(&mut self, credential: &StakeCredential) { + fn deregister_stake_address(&mut self, stake_address: &StakeAddress) { let Some(stake_addresses) = self.stake_addresses.as_ref() else { return; }; - let stake_address = credential.to_stake_address(None); let mut stake_addresses = stake_addresses.lock().unwrap(); - let old_spo = stake_addresses.get(&stake_address).map(|s| s.delegated_spo.clone()).flatten(); + let old_spo = + stake_addresses.get(&stake_address).map(|s| s.delegated_spo.clone()).flatten(); if stake_addresses.deregister_stake_address(&stake_address) { // update historical_spos @@ -449,12 +459,12 @@ impl State { if let Some(old_spo) = old_spo.as_ref() { // remove delegators from old_spo if let Some(historical_spo) = historical_spos.get_mut(old_spo) { - if let Some(removed) = historical_spo.remove_delegator(&credential.to_stake_address(None)) { + if let Some(removed) = historical_spo.remove_delegator(stake_address) { if !removed { error!( "Historical SPO state for {} does not contain delegator {}", hex::encode(old_spo), - hex::encode(&credential.get_hash()) + stake_address ); } } @@ -466,14 +476,13 @@ impl State { /// Record a stake delegation /// Update historical_spo_state's delegators - fn record_stake_delegation(&mut self, credential: &StakeCredential, spo: &KeyHash) { + fn record_stake_delegation(&mut self, stake_address: &StakeAddress, spo: &KeyHash) { let Some(stake_addresses) = self.stake_addresses.as_ref() else { return; }; - let hash = credential.get_hash(); - let stake_address = credential.to_stake_address(None); let mut stake_addresses = stake_addresses.lock().unwrap(); - let old_spo = stake_addresses.get(&stake_address).map(|s| s.delegated_spo.clone()).flatten(); + let old_spo = + stake_addresses.get(&stake_address).map(|s| s.delegated_spo.clone()).flatten(); if stake_addresses.record_stake_delegation(&stake_address, spo) { // update historical_spos @@ -487,7 +496,7 @@ impl State { error!( "Historical SPO state for {} does not contain delegator {}", hex::encode(old_spo), - hex::encode(&hash) + stake_address ); } } @@ -507,7 +516,7 @@ impl State { error!( "Historical SPO state for {} already contains delegator {}", hex::encode(spo), - hex::encode(&hash) + stake_address ); } } @@ -539,38 +548,38 @@ impl State { } // for stake addresses - TxCertificate::StakeRegistration(sc_with_pos) => { - self.register_stake_address(&sc_with_pos.stake_credential); + TxCertificate::StakeRegistration(stake_address_with_pos) => { + self.register_stake_address(&stake_address_with_pos.stake_address); } - TxCertificate::StakeDeregistration(sc) => { - self.deregister_stake_address(&sc); + TxCertificate::StakeDeregistration(stake_address) => { + self.deregister_stake_address(&stake_address); } TxCertificate::Registration(reg) => { - self.register_stake_address(®.credential); + self.register_stake_address(®.stake_address); // we don't care deposite } TxCertificate::Deregistration(dreg) => { - self.deregister_stake_address(&dreg.credential); + self.deregister_stake_address(&dreg.stake_address); // we don't care refund } TxCertificate::StakeDelegation(delegation) => { - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); } TxCertificate::StakeAndVoteDelegation(delegation) => { - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); // don't care about vote delegation } TxCertificate::StakeRegistrationAndDelegation(delegation) => { - self.register_stake_address(&delegation.credential); - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.register_stake_address(&delegation.stake_address); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); } TxCertificate::StakeRegistrationAndVoteDelegation(delegation) => { - self.register_stake_address(&delegation.credential); + self.register_stake_address(&delegation.stake_address); // don't care about vote delegation } TxCertificate::StakeRegistrationAndStakeAndVoteDelegation(delegation) => { - self.register_stake_address(&delegation.credential); - self.record_stake_delegation(&delegation.credential, &delegation.operator); + self.register_stake_address(&delegation.stake_address); + self.record_stake_delegation(&delegation.stake_address, &delegation.operator); // don't care about vote delegation } _ => (), @@ -653,7 +662,10 @@ impl State { for delta in reward_deltas_msg.deltas.iter() { let mut stake_addresses = stake_addresses.lock().unwrap(); if let Err(e) = stake_addresses.update_reward(&delta.stake_address, delta.delta) { - error!("Updating reward account {}: {e}", hex::encode(&delta.stake_address.get_hash())); + error!( + "Updating reward account {}: {e}", + hex::encode(&delta.stake_address.get_hash()) + ); } } @@ -672,14 +684,19 @@ mod tests { use crate::test_utils::*; use acropolis_common::{ state_history::{StateHistory, StateHistoryStore}, - Credential, PoolRetirement, Ratio, StakeAddress, TxCertificate, TxHash, + NetworkId, PoolRetirement, Ratio, StakeAddress, StakeAddressPayload, TxCertificate, TxHash, }; use tokio::sync::Mutex; - fn pool_owners_from_bytes(owners: Vec>) -> Vec { + fn pool_owners_from_bytes(owners: Vec>) -> Vec { owners .into_iter() - .map(|bytes| Credential::AddrKeyHash(bytes)) + .map(|bytes| { + StakeAddress::new( + StakeAddressPayload::StakeKeyHash(bytes), + NetworkId::default().into(), + ) + }) .collect() } @@ -694,7 +711,7 @@ mod tests { denominator: 0, }, reward_account: StakeAddress::default(), - pool_owners: pool_owners_from_bytes(vec![operator]), + pool_owners: pool_owners_from_bytes(vec![StakeAddress::default().get_hash().to_vec()]), relays: vec![], pool_metadata: None, } diff --git a/modules/spo_state/src/test_utils.rs b/modules/spo_state/src/test_utils.rs index 2e8772d8..b1fd1484 100644 --- a/modules/spo_state/src/test_utils.rs +++ b/modules/spo_state/src/test_utils.rs @@ -1,9 +1,6 @@ -use acropolis_common::{ - messages::{ - EpochActivityMessage, SPORewardsMessage, SPOStakeDistributionMessage, TxCertificatesMessage, - }, - BlockHash, BlockInfo, BlockStatus, Era, TxCertificate, -}; +use acropolis_common::{messages::{ + EpochActivityMessage, SPORewardsMessage, SPOStakeDistributionMessage, TxCertificatesMessage, +}, BlockHash, BlockInfo, BlockStatus, Era, TxCertificate}; use crate::store_config::StoreConfig; diff --git a/modules/stake_delta_filter/src/state.rs b/modules/stake_delta_filter/src/state.rs index 59dbb56f..df90cc38 100644 --- a/modules/stake_delta_filter/src/state.rs +++ b/modules/stake_delta_filter/src/state.rs @@ -7,8 +7,7 @@ use acropolis_common::{ AddressDeltasMessage, CardanoMessage, Message, StakeAddressDeltasMessage, TxCertificatesMessage, }, - Address, BlockInfo, ShelleyAddressPointer, StakeAddress, StakeAddressPayload, StakeCredential, - TxCertificate, + Address, BlockInfo, ShelleyAddressPointer, TxCertificate, }; use anyhow::Result; use serde_with::serde_as; @@ -93,17 +92,7 @@ impl State { cert_index: reg.cert_index, }; - let stake_address = StakeAddress { - network: self.params.network.clone(), - payload: match ®.stake_credential { - StakeCredential::ScriptHash(h) => { - StakeAddressPayload::ScriptHash(h.clone()) - } - StakeCredential::AddrKeyHash(k) => { - StakeAddressPayload::StakeKeyHash(k.clone()) - } - }, - }; + let stake_address = reg.stake_address.clone(); // Sets pointer; updates max processed slot self.pointer_cache.set_pointer(ptr, stake_address, block.slot); diff --git a/modules/stake_delta_filter/src/utils.rs b/modules/stake_delta_filter/src/utils.rs index 334df1cd..d4919122 100644 --- a/modules/stake_delta_filter/src/utils.rs +++ b/modules/stake_delta_filter/src/utils.rs @@ -401,8 +401,9 @@ mod test { use crate::*; use acropolis_common::{ messages::AddressDeltasMessage, Address, AddressDelta, BlockHash, BlockInfo, BlockStatus, - ByronAddress, Era, ShelleyAddress, ShelleyAddressDelegationPart, ShelleyAddressPaymentPart, - ShelleyAddressPointer, StakeAddress, StakeAddressPayload, ValueDelta, + ByronAddress, Era, ShelleyAddress, ShelleyAddressDelegationPart, + ShelleyAddressPaymentPart, ShelleyAddressPointer, StakeAddress, StakeAddressPayload, + ValueDelta, }; use bech32::{Bech32, Hrp}; diff --git a/modules/tx_unpacker/src/map_parameters.rs b/modules/tx_unpacker/src/map_parameters.rs index 1439479e..1bd4f23f 100644 --- a/modules/tx_unpacker/src/map_parameters.rs +++ b/modules/tx_unpacker/src/map_parameters.rs @@ -93,6 +93,20 @@ pub fn map_stake_credential(cred: &PallasStakeCredential) -> StakeCredential { } } +/// Map a PallasStakeCredential to our StakeAddress +pub fn map_stake_address(cred: &PallasStakeCredential, network_id: NetworkId) -> StakeAddress { + let payload = match cred { + PallasStakeCredential::AddrKeyhash(key_hash) => { + StakeAddressPayload::StakeKeyHash(key_hash.to_vec()) + } + PallasStakeCredential::ScriptHash(script_hash) => { + StakeAddressPayload::ScriptHash(script_hash.to_vec()) + } + }; + + StakeAddress::new(payload, network_id.into()) +} + /// Map a Pallas DRep to our DRepChoice pub fn map_drep(drep: &conway::DRep) -> DRepChoice { match drep { @@ -203,24 +217,25 @@ pub fn map_certificate( tx_hash: TxHash, tx_index: u16, cert_index: usize, + network_id: NetworkId, ) -> Result { match cert { MultiEraCert::NotApplicable => Err(anyhow!("Not applicable cert!")), MultiEraCert::AlonzoCompatible(cert) => match cert.as_ref().as_ref() { alonzo::Certificate::StakeRegistration(cred) => { - Ok(TxCertificate::StakeRegistration(StakeCredentialWithPos { - stake_credential: map_stake_credential(cred), + Ok(TxCertificate::StakeRegistration(StakeAddressWithPos { + stake_address: map_stake_address(cred, network_id), tx_index: tx_index.try_into().unwrap(), cert_index: cert_index.try_into().unwrap(), })) } alonzo::Certificate::StakeDeregistration(cred) => Ok( - TxCertificate::StakeDeregistration(map_stake_credential(cred)), + TxCertificate::StakeDeregistration(map_stake_address(cred, network_id)), ), alonzo::Certificate::StakeDelegation(cred, pool_key_hash) => { Ok(TxCertificate::StakeDelegation(StakeDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), operator: pool_key_hash.to_vec(), })) } @@ -246,7 +261,15 @@ pub fn map_certificate( denominator: margin.denominator, }, reward_account: StakeAddress::from_binary(reward_account)?, - pool_owners: pool_owners.into_iter().map(|v| Credential::AddrKeyHash(v.to_vec())).collect(), + pool_owners: pool_owners + .into_iter() + .map(|v| { + StakeAddress::new( + StakeAddressPayload::StakeKeyHash(v.to_vec()), + network_id.clone().into(), + ) + }) + .collect(), relays: relays.into_iter().map(|relay| map_relay(relay)).collect(), pool_metadata: match pool_metadata { Nullable::Some(md) => Some(PoolMetadata { @@ -291,10 +314,10 @@ pub fn map_certificate( }, target: match &mir.target { alonzo::InstantaneousRewardTarget::StakeCredentials(creds) => { - InstantaneousRewardTarget::StakeCredentials( + InstantaneousRewardTarget::StakeAddresses( creds .iter() - .map(|(sc, v)| (map_stake_credential(&sc), *v)) + .map(|(sc, v)| (map_stake_address(&sc, network_id.clone()), *v)) .collect(), ) } @@ -310,18 +333,18 @@ pub fn map_certificate( MultiEraCert::Conway(cert) => { match cert.as_ref().as_ref() { conway::Certificate::StakeRegistration(cred) => { - Ok(TxCertificate::StakeRegistration(StakeCredentialWithPos { - stake_credential: map_stake_credential(cred), + Ok(TxCertificate::StakeRegistration(StakeAddressWithPos { + stake_address: map_stake_address(cred, network_id), tx_index: tx_index.try_into().unwrap(), cert_index: cert_index.try_into().unwrap(), })) } conway::Certificate::StakeDeregistration(cred) => Ok( - TxCertificate::StakeDeregistration(map_stake_credential(cred)), + TxCertificate::StakeDeregistration(map_stake_address(cred, network_id)), ), conway::Certificate::StakeDelegation(cred, pool_key_hash) => { Ok(TxCertificate::StakeDelegation(StakeDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), operator: pool_key_hash.to_vec(), })) } @@ -348,7 +371,15 @@ pub fn map_certificate( denominator: margin.denominator, }, reward_account: StakeAddress::from_binary(reward_account)?, - pool_owners: pool_owners.into_iter().map(|v| Credential::AddrKeyHash(v.to_vec())).collect(), + pool_owners: pool_owners + .into_iter() + .map(|v| { + StakeAddress::new( + StakeAddressPayload::StakeKeyHash(v.to_vec()), + network_id.clone().into(), + ) + }) + .collect(), relays: relays.into_iter().map(|relay| map_relay(relay)).collect(), pool_metadata: match pool_metadata { Nullable::Some(md) => Some(PoolMetadata { @@ -375,28 +406,28 @@ pub fn map_certificate( conway::Certificate::Reg(cred, coin) => { Ok(TxCertificate::Registration(Registration { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), deposit: *coin, })) } conway::Certificate::UnReg(cred, coin) => { Ok(TxCertificate::Deregistration(Deregistration { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), refund: *coin, })) } conway::Certificate::VoteDeleg(cred, drep) => { Ok(TxCertificate::VoteDelegation(VoteDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), drep: map_drep(drep), })) } conway::Certificate::StakeVoteDeleg(cred, pool_key_hash, drep) => Ok( TxCertificate::StakeAndVoteDelegation(StakeAndVoteDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), operator: pool_key_hash.to_vec(), drep: map_drep(drep), }), @@ -404,7 +435,7 @@ pub fn map_certificate( conway::Certificate::StakeRegDeleg(cred, pool_key_hash, coin) => Ok( TxCertificate::StakeRegistrationAndDelegation(StakeRegistrationAndDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), operator: pool_key_hash.to_vec(), deposit: *coin, }), @@ -413,7 +444,7 @@ pub fn map_certificate( conway::Certificate::VoteRegDeleg(cred, drep, coin) => { Ok(TxCertificate::StakeRegistrationAndVoteDelegation( StakeRegistrationAndVoteDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), drep: map_drep(drep), deposit: *coin, }, @@ -423,7 +454,7 @@ pub fn map_certificate( conway::Certificate::StakeVoteRegDeleg(cred, pool_key_hash, drep, coin) => { Ok(TxCertificate::StakeRegistrationAndStakeAndVoteDelegation( StakeRegistrationAndStakeAndVoteDelegation { - credential: map_stake_credential(cred), + stake_address: map_stake_address(cred, network_id), operator: pool_key_hash.to_vec(), drep: map_drep(drep), deposit: *coin, diff --git a/modules/tx_unpacker/src/tx_unpacker.rs b/modules/tx_unpacker/src/tx_unpacker.rs index 03f28759..6bd246a0 100644 --- a/modules/tx_unpacker/src/tx_unpacker.rs +++ b/modules/tx_unpacker/src/tx_unpacker.rs @@ -103,6 +103,9 @@ impl TxUnpacker { info!("Publishing block txs on '{topic}'"); } + let network_id: NetworkId = + config.get_string("network-id").unwrap_or("mainnet".to_string()).into(); + // Initialize UTxORegistry let mut utxo_registry = UTxORegistry::default(); @@ -267,7 +270,7 @@ impl TxUnpacker { if publish_certificates_topic.is_some() { let tx_hash = tx.hash(); for ( cert_index, cert) in certs.iter().enumerate() { - match map_parameters::map_certificate(&cert, *tx_hash, tx_index, cert_index) { + match map_parameters::map_certificate(&cert, *tx_hash, tx_index, cert_index, network_id.clone()) { Ok(tx_cert) => { certificates.push(tx_cert); }, diff --git a/modules/upstream_chain_fetcher/src/body_fetcher.rs b/modules/upstream_chain_fetcher/src/body_fetcher.rs index afa2a5ee..d84104c0 100644 --- a/modules/upstream_chain_fetcher/src/body_fetcher.rs +++ b/modules/upstream_chain_fetcher/src/body_fetcher.rs @@ -1,10 +1,7 @@ //! Acropolis Miniprotocols module for Caryatid //! Multi-connection, block body fetching part of the client (in separate thread). -use acropolis_common::{ - messages::{BlockBodyMessage, BlockHeaderMessage}, - BlockInfo, BlockStatus, Era, -}; +use acropolis_common::{messages::{BlockBodyMessage, BlockHeaderMessage}, BlockInfo, BlockStatus, Era}; use anyhow::{bail, Result}; use crossbeam::channel::{Receiver, TryRecvError}; use pallas::{ diff --git a/modules/upstream_chain_fetcher/src/upstream_cache.rs b/modules/upstream_chain_fetcher/src/upstream_cache.rs index 9281a358..022b13c7 100644 --- a/modules/upstream_chain_fetcher/src/upstream_cache.rs +++ b/modules/upstream_chain_fetcher/src/upstream_cache.rs @@ -151,8 +151,7 @@ impl Storage for FileStorage { let file = File::open(&name)?; let reader = BufReader::new(file); - match serde_json::from_reader::, Vec>(reader) - { + match serde_json::from_reader::, Vec>(reader) { Ok(res) => Ok(res.clone()), Err(err) => Err(anyhow!( "Error reading upstream cache chunk JSON from {name}: '{err}'" diff --git a/processes/golden_tests/src/test_module.rs b/processes/golden_tests/src/test_module.rs index 61377e6b..f0fd85de 100644 --- a/processes/golden_tests/src/test_module.rs +++ b/processes/golden_tests/src/test_module.rs @@ -1,11 +1,7 @@ -use acropolis_common::{ - ledger_state::LedgerState, - messages::{ - CardanoMessage, Message, RawTxsMessage, SnapshotDumpMessage, SnapshotMessage, - SnapshotStateMessage, - }, - BlockHash, BlockInfo, BlockStatus, Era, -}; +use acropolis_common::{ledger_state::LedgerState, messages::{ + CardanoMessage, Message, RawTxsMessage, SnapshotDumpMessage, SnapshotMessage, + SnapshotStateMessage, +}, BlockHash, BlockInfo, BlockStatus, Era}; use anyhow::{Context as AnyhowContext, Result}; use caryatid_sdk::{module, Context, Module}; use config::Config; diff --git a/processes/omnibus/omnibus.toml b/processes/omnibus/omnibus.toml index 4fa7998e..d4f96049 100644 --- a/processes/omnibus/omnibus.toml +++ b/processes/omnibus/omnibus.toml @@ -26,6 +26,7 @@ publish-withdrawals-topic = "cardano.withdrawals" publish-certificates-topic = "cardano.certificates" publish-governance-topic = "cardano.governance" publish-block-txs-topic = "cardano.block.txs" +network-name = "mainnet" [module.utxo-state] store = "memory" # "memory", "dashmap", "fjall", "fjall-async", "sled", "sled-async", "fake"