From ff78e0f556a6ebf08a3d481425f38112259f8a53 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 10:58:07 +0200 Subject: [PATCH 01/49] Modifiy zebra-chain structures to support multiple action groups --- zebra-chain/src/orchard.rs | 2 +- zebra-chain/src/orchard/shielded_data.rs | 98 ++++++++++++++++--- .../src/orchard/shielded_data_flavor.rs | 2 + zebra-chain/src/transaction.rs | 28 +++--- zebra-chain/src/transaction/arbitrary.rs | 35 ++++--- zebra-chain/src/transaction/serialize.rs | 70 ++++++++----- zebra-consensus/src/primitives/halo2.rs | 14 +-- zebra-consensus/src/transaction.rs | 15 +-- zebra-consensus/src/transaction/check.rs | 3 +- zebra-state/src/service/check/anchors.rs | 6 +- .../src/service/check/tests/nullifier.rs | 8 +- .../finalized_state/zebra_db/arbitrary.rs | 2 +- .../components/mempool/storage/tests/prop.rs | 13 ++- 13 files changed, 206 insertions(+), 90 deletions(-) diff --git a/zebra-chain/src/orchard.rs b/zebra-chain/src/orchard.rs index 290ddb4931a..2a2e5ac7c37 100644 --- a/zebra-chain/src/orchard.rs +++ b/zebra-chain/src/orchard.rs @@ -23,7 +23,7 @@ pub use address::Address; pub use commitment::{CommitmentRandomness, NoteCommitment, ValueCommitment}; pub use keys::Diversifier; pub use note::{EncryptedNote, Note, Nullifier, WrappedNoteKey}; -pub use shielded_data::{AuthorizedAction, Flags, ShieldedData}; +pub use shielded_data::{ActionGroup, AuthorizedAction, Flags, ShieldedData}; pub use shielded_data_flavor::{OrchardVanilla, ShieldedDataFlavor}; pub(crate) use shielded_data::ActionCommon; diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index 292ebe34266..68c29fc97d0 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -22,19 +22,18 @@ use crate::{ use super::{OrchardVanilla, ShieldedDataFlavor}; -/// A bundle of [`Action`] descriptions and signature data. +// FIXME: wrap all ActionGroup usages withj tx-v6 feature flag? +/// FIXME: add doc +#[cfg(feature = "tx-v6")] #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)] #[serde(bound( serialize = "FL::EncryptedNote: serde::Serialize, FL::BurnType: serde::Serialize", deserialize = "FL::BurnType: serde::Deserialize<'de>" ))] -pub struct ShieldedData { +pub struct ActionGroup { /// The orchard flags for this transaction. /// Denoted as `flagsOrchard` in the spec. pub flags: Flags, - /// The net value of Orchard spends minus outputs. - /// Denoted as `valueBalanceOrchard` in the spec. - pub value_balance: Amount, /// The shared anchor for all `Spend`s in this transaction. /// Denoted as `anchorOrchard` in the spec. pub shared_anchor: tree::Root, @@ -44,28 +43,66 @@ pub struct ShieldedData { /// The Orchard Actions, in the order they appear in the transaction. /// Denoted as `vActionsOrchard` and `vSpendAuthSigsOrchard` in the spec. pub actions: AtLeastOne>, - /// A signature on the transaction `sighash`. - /// Denoted as `bindingSigOrchard` in the spec. - pub binding_sig: Signature, #[cfg(feature = "tx-v6")] /// Assets intended for burning /// Denoted as `vAssetBurn` in the spec (ZIP 230). - pub burn: FL::BurnType, + pub(crate) burn: FL::BurnType, } -impl fmt::Display for ShieldedData { +impl ActionGroup { + /// Iterate over the [`Action`]s for the [`AuthorizedAction`]s in this + /// action group, in the order they appear in it. + pub fn actions(&self) -> impl Iterator> { + self.actions.actions() + } +} + +/// A bundle of [`Action`] descriptions and signature data. +#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)] +#[serde(bound( + serialize = "FL::EncryptedNote: serde::Serialize, FL::BurnType: serde::Serialize", + deserialize = "FL::BurnType: serde::Deserialize<'de>" +))] +pub struct ShieldedData { + /// FIXME: add doc + pub action_groups: AtLeastOne>, + /// Denoted as `valueBalanceOrchard` in the spec. + pub value_balance: Amount, + /// A signature on the transaction `sighash`. + /// Denoted as `bindingSigOrchard` in the spec. + pub binding_sig: Signature, +} + +impl fmt::Display for ActionGroup { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut fmter = f.debug_struct("orchard::ShieldedData"); + let mut fmter = f.debug_struct("orchard::ActionGroup"); + + // FIXME: reorder fields here according the struct/spec? fmter.field("actions", &self.actions.len()); - fmter.field("value_balance", &self.value_balance); fmter.field("flags", &self.flags); fmter.field("proof_len", &self.proof.zcash_serialized_size()); fmter.field("shared_anchor", &self.shared_anchor); + #[cfg(feature = "tx-v6")] + fmter.field("burn", &self.burn.as_ref().len()); + + fmter.finish() + } +} + +impl fmt::Display for ShieldedData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut fmter = f.debug_struct("orchard::ShieldedData"); + + fmter.field("action_groups", &self.action_groups); + fmter.field("value_balance", &self.value_balance); + + // FIXME: format binding_sig as well? + fmter.finish() } } @@ -74,13 +111,14 @@ impl ShieldedData { /// Iterate over the [`Action`]s for the [`AuthorizedAction`]s in this /// transaction, in the order they appear in it. pub fn actions(&self) -> impl Iterator> { - self.actions.actions() + self.authorized_actions() + .map(|authorized_action| &authorized_action.action) } /// Return an iterator for the [`ActionCommon`] copy of the Actions in this /// transaction, in the order they appear in it. pub fn action_commons(&self) -> impl Iterator + '_ { - self.actions.actions().map(|action| action.into()) + self.actions().map(|action| action.into()) } /// Collect the [`Nullifier`]s for this transaction. @@ -123,7 +161,14 @@ impl ShieldedData { // FIXME: use asset to create ValueCommitment here for burns and above for value_balance? #[cfg(feature = "tx-v6")] - let key_bytes: [u8; 32] = (cv - cv_balance - self.burn.clone().into()).into(); + let key_bytes: [u8; 32] = (cv + - cv_balance + - self + .action_groups + .iter() + .map(|action_group| action_group.burn.clone().into()) + .sum::()) + .into(); key_bytes.into() } @@ -140,6 +185,29 @@ impl ShieldedData { pub fn note_commitments(&self) -> impl Iterator { self.actions().map(|action| &action.cm_x) } + + /// Makes a union of the flags for this transaction. + pub fn flags_union(&self) -> Flags { + self.action_groups + .iter() + .map(|action_group| &action_group.flags) + .fold(Flags::empty(), |result, flags| result.union(*flags)) + } + + /// Collect the shared anchors for this transaction. + pub fn shared_anchors(&self) -> impl Iterator + '_ { + self.action_groups + .iter() + .map(|action_group| action_group.shared_anchor.clone()) + } + + /// Iterate over the [`AuthorizedAction`]s in this + /// transaction, in the order they appear in it. + pub fn authorized_actions(&self) -> impl Iterator> { + self.action_groups + .iter() + .flat_map(|action_group| action_group.actions.iter()) + } } impl AtLeastOne> { diff --git a/zebra-chain/src/orchard/shielded_data_flavor.rs b/zebra-chain/src/orchard/shielded_data_flavor.rs index ec3bc24cb58..02bb45fadfc 100644 --- a/zebra-chain/src/orchard/shielded_data_flavor.rs +++ b/zebra-chain/src/orchard/shielded_data_flavor.rs @@ -57,6 +57,8 @@ pub trait ShieldedDataFlavor: OrchardFlavor { type BurnType: Clone + Debug + Default + + PartialEq + + Eq + ZcashDeserialize + ZcashSerialize + Into diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs index 5a96cc530af..0c59a4b0c8c 100644 --- a/zebra-chain/src/transaction.rs +++ b/zebra-chain/src/transaction.rs @@ -80,8 +80,8 @@ macro_rules! orchard_shielded_data_iter { // FIXME: doc this // Move down -macro_rules! orchard_shielded_data_field { - ($self:expr, $field:ident) => { +macro_rules! orchard_shielded_data_method { + ($self:expr, $method:ident) => { match $self { // No Orchard shielded data Transaction::V1 { .. } @@ -92,13 +92,13 @@ macro_rules! orchard_shielded_data_field { Transaction::V5 { orchard_shielded_data, .. - } => orchard_shielded_data.as_ref().map(|data| data.$field), + } => orchard_shielded_data.as_ref().map(|data| data.$method()), #[cfg(feature = "tx-v6")] Transaction::V6 { orchard_shielded_data, .. - } => orchard_shielded_data.as_ref().map(|data| data.$field), + } => orchard_shielded_data.as_ref().map(|data| data.$method()), } }; } @@ -354,11 +354,12 @@ impl Transaction { /// /// See [`Self::has_transparent_or_shielded_inputs`] for details. pub fn has_shielded_inputs(&self) -> bool { + // FIXME: is it correct to use orchard_flags_union here? self.joinsplit_count() > 0 || self.sapling_spends_per_anchor().count() > 0 || (self.orchard_actions().count() > 0 && self - .orchard_flags() + .orchard_flags_union() .unwrap_or_else(orchard::Flags::empty) .contains(orchard::Flags::ENABLE_SPENDS)) } @@ -372,11 +373,12 @@ impl Transaction { /// /// See [`Self::has_transparent_or_shielded_outputs`] for details. pub fn has_shielded_outputs(&self) -> bool { + // FIXME: is it correct to use orchard_flags_union here? self.joinsplit_count() > 0 || self.sapling_outputs().count() > 0 || (self.orchard_actions().count() > 0 && self - .orchard_flags() + .orchard_flags_union() .unwrap_or_else(orchard::Flags::empty) .contains(orchard::Flags::ENABLE_OUTPUTS)) } @@ -386,7 +388,7 @@ impl Transaction { if self.version() < 5 || self.orchard_actions().count() == 0 { return true; } - self.orchard_flags() + self.orchard_flags_union() .unwrap_or_else(orchard::Flags::empty) .intersects(orchard::Flags::ENABLE_SPENDS | orchard::Flags::ENABLE_OUTPUTS) } @@ -1070,20 +1072,20 @@ impl Transaction { /// Access the [`orchard::Flags`] in this transaction, if there is any, /// regardless of version. - pub fn orchard_flags(&self) -> Option { - orchard_shielded_data_field!(self, flags) + pub fn orchard_flags_union(&self) -> Option { + orchard_shielded_data_method!(self, flags_union) } /// Access the [`orchard::tree::Root`] in this transaction, if there is any, /// regardless of version. - pub fn orchard_shared_anchor(&self) -> Option { - orchard_shielded_data_field!(self, shared_anchor) + pub fn orchard_shared_anchors(&self) -> Box + '_> { + orchard_shielded_data_iter!(self, orchard::ShieldedData::shared_anchors) } /// Return if the transaction has any Orchard shielded data, /// regardless of version. pub fn has_orchard_shielded_data(&self) -> bool { - self.orchard_flags().is_some() + orchard_shielded_data_method!(self, value_balance).is_some() } // value balances @@ -1458,7 +1460,7 @@ impl Transaction { /// pub fn orchard_value_balance(&self) -> ValueBalance { let orchard_value_balance = - orchard_shielded_data_field!(self, value_balance).unwrap_or_else(Amount::zero); + orchard_shielded_data_method!(self, value_balance).unwrap_or_else(Amount::zero); ValueBalance::from_orchard_amount(orchard_value_balance) } diff --git a/zebra-chain/src/transaction/arbitrary.rs b/zebra-chain/src/transaction/arbitrary.rs index 4394e588c91..1c16ee44d32 100644 --- a/zebra-chain/src/transaction/arbitrary.rs +++ b/zebra-chain/src/transaction/arbitrary.rs @@ -14,7 +14,7 @@ use crate::{ parameters::{Network, NetworkUpgrade}, primitives::{Bctv14Proof, Groth16Proof, Halo2Proof, ZkSnarkProof}, sapling::{self, AnchorVariant, PerSpendAnchor, SharedAnchor}, - serialization::ZcashDeserializeInto, + serialization::{AtLeastOne, ZcashDeserializeInto}, sprout, transparent, value_balance::{ValueBalance, ValueBalanceError}, LedgerState, @@ -811,17 +811,20 @@ impl Arbitrary for orchard::ShieldedD let (flags, value_balance, shared_anchor, proof, actions, binding_sig, burn) = props; + // FIXME: support multiple action groups Self { - flags, + action_groups: AtLeastOne::from_one(orchard::ActionGroup { + flags, + shared_anchor, + proof, + actions: actions + .try_into() + .expect("arbitrary vector size range produces at least one action"), + #[cfg(feature = "tx-v6")] + burn, + }), value_balance, - shared_anchor, - proof, - actions: actions - .try_into() - .expect("arbitrary vector size range produces at least one action"), binding_sig: binding_sig.0, - #[cfg(feature = "tx-v6")] - burn, } }) .boxed() @@ -1157,14 +1160,16 @@ pub fn insert_fake_orchard_shielded_data( // Place the dummy action inside the Orchard shielded data let dummy_shielded_data = orchard::ShieldedData:: { - flags: orchard::Flags::empty(), + action_groups: AtLeastOne::from_one(orchard::ActionGroup { + flags: orchard::Flags::empty(), + shared_anchor: orchard::tree::Root::default(), + proof: Halo2Proof(vec![]), + actions: at_least_one![dummy_authorized_action], + #[cfg(feature = "tx-v6")] + burn: Default::default(), + }), value_balance: Amount::try_from(0).expect("invalid transaction amount"), - shared_anchor: orchard::tree::Root::default(), - proof: Halo2Proof(vec![]), - actions: at_least_one![dummy_authorized_action], binding_sig: Signature::from([0u8; 64]), - #[cfg(feature = "tx-v6")] - burn: Default::default(), }; // Replace the shielded data in the transaction diff --git a/zebra-chain/src/transaction/serialize.rs b/zebra-chain/src/transaction/serialize.rs index fdecf4e3fef..4034f4eb960 100644 --- a/zebra-chain/src/transaction/serialize.rs +++ b/zebra-chain/src/transaction/serialize.rs @@ -11,7 +11,7 @@ use reddsa::{orchard::Binding, orchard::SpendAuth, Signature}; use crate::{ amount, block::MAX_BLOCK_BYTES, - orchard::{OrchardVanilla, OrchardZSA}, + orchard::{ActionGroup, OrchardVanilla, OrchardZSA}, parameters::{OVERWINTER_VERSION_GROUP_ID, SAPLING_VERSION_GROUP_ID, TX_V5_VERSION_GROUP_ID}, primitives::{Halo2Proof, ZkSnarkProof}, serialization::{ @@ -351,11 +351,18 @@ impl ZcashSerialize for Option> { impl ZcashSerialize for orchard::ShieldedData { fn zcash_serialize(&self, mut writer: W) -> Result<(), io::Error> { + assert!( + self.action_groups.len() == 1, + "only one action group is supported for transaction V5" + ); + + let action_group = self.action_groups.first(); + // Split the AuthorizedAction let (actions, sigs): ( Vec>, Vec>, - ) = self + ) = action_group .actions .iter() .cloned() @@ -366,16 +373,16 @@ impl ZcashSerialize for orchard::ShieldedData { actions.zcash_serialize(&mut writer)?; // Denoted as `flagsOrchard` in the spec. - self.flags.zcash_serialize(&mut writer)?; + action_group.flags.zcash_serialize(&mut writer)?; // Denoted as `valueBalanceOrchard` in the spec. self.value_balance.zcash_serialize(&mut writer)?; // Denoted as `anchorOrchard` in the spec. - self.shared_anchor.zcash_serialize(&mut writer)?; + action_group.shared_anchor.zcash_serialize(&mut writer)?; // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. - self.proof.zcash_serialize(&mut writer)?; + action_group.proof.zcash_serialize(&mut writer)?; // Denoted as `vSpendAuthSigsOrchard` in the spec. zcash_serialize_external_count(&sigs, &mut writer)?; @@ -415,30 +422,39 @@ impl ZcashSerialize for Option> { #[allow(clippy::unwrap_in_result)] impl ZcashSerialize for orchard::ShieldedData { fn zcash_serialize(&self, mut writer: W) -> Result<(), io::Error> { + // FIXME: support multiple action groups + assert!( + self.action_groups.len() == 1, + "only one action group is supported for transaction V6 for now" + ); + + let action_group = self.action_groups.first(); + // Exactly one action group for NU7 CompactSizeMessage::try_from(1) .expect("1 should convert to CompactSizeMessage") .zcash_serialize(&mut writer)?; // Split the AuthorizedAction - let (actions, sigs): (Vec>, Vec>) = self - .actions - .iter() - .cloned() - .map(orchard::AuthorizedAction::into_parts) - .unzip(); + let (actions, sigs): (Vec>, Vec>) = + action_group + .actions + .iter() + .cloned() + .map(orchard::AuthorizedAction::into_parts) + .unzip(); // Denoted as `nActionsOrchard` and `vActionsOrchard` in the spec. actions.zcash_serialize(&mut writer)?; // Denoted as `flagsOrchard` in the spec. - self.flags.zcash_serialize(&mut writer)?; + action_group.flags.zcash_serialize(&mut writer)?; // Denoted as `anchorOrchard` in the spec. - self.shared_anchor.zcash_serialize(&mut writer)?; + action_group.shared_anchor.zcash_serialize(&mut writer)?; // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. - self.proof.zcash_serialize(&mut writer)?; + action_group.proof.zcash_serialize(&mut writer)?; // Timelimit must be zero for NU7 writer.write_u32::(0)?; @@ -450,7 +466,7 @@ impl ZcashSerialize for orchard::ShieldedData { self.value_balance.zcash_serialize(&mut writer)?; // Denoted as `vAssetBurn` in the spec (ZIP 230). - self.burn.zcash_serialize(&mut writer)?; + action_group.burn.zcash_serialize(&mut writer)?; // Denoted as `bindingSigOrchard` in the spec. self.binding_sig.zcash_serialize(&mut writer)?; @@ -523,12 +539,14 @@ impl ZcashDeserialize for Option> { authorized_actions.try_into()?; Ok(Some(orchard::ShieldedData:: { - flags, + action_groups: AtLeastOne::from_one(ActionGroup { + flags, + shared_anchor, + proof, + actions, + burn: Default::default(), + }), value_balance, - burn: Default::default(), - shared_anchor, - proof, - actions, binding_sig, })) } @@ -615,12 +633,14 @@ impl ZcashDeserialize for Option> { authorized_actions.try_into()?; Ok(Some(orchard::ShieldedData:: { - flags, + action_groups: AtLeastOne::from_one(ActionGroup { + flags, + shared_anchor, + proof, + actions, + burn, + }), value_balance, - burn, - shared_anchor, - proof, - actions, binding_sig, })) } diff --git a/zebra-consensus/src/primitives/halo2.rs b/zebra-consensus/src/primitives/halo2.rs index ea07b79a253..560a5f28a8b 100644 --- a/zebra-consensus/src/primitives/halo2.rs +++ b/zebra-consensus/src/primitives/halo2.rs @@ -19,7 +19,7 @@ use tower::{util::ServiceFn, Service}; use tower_batch_control::{Batch, BatchControl}; use tower_fallback::Fallback; -use zebra_chain::orchard::{OrchardVanilla, OrchardZSA, ShieldedData, ShieldedDataFlavor}; +use zebra_chain::orchard::{ActionGroup, OrchardVanilla, OrchardZSA, ShieldedDataFlavor}; use crate::BoxError; @@ -136,16 +136,16 @@ impl BatchVerifier { // === END TEMPORARY BATCH HALO2 SUBSTITUTE === -impl From<&ShieldedData> for Item { - fn from(shielded_data: &ShieldedData) -> Item { +impl From<&ActionGroup> for Item { + fn from(action_group: &ActionGroup) -> Item { use orchard::{circuit, note, primitives::redpallas, tree, value}; - let anchor = tree::Anchor::from_bytes(shielded_data.shared_anchor.into()).unwrap(); + let anchor = tree::Anchor::from_bytes(action_group.shared_anchor.into()).unwrap(); - let flags = orchard::bundle::Flags::from_byte(shielded_data.flags.bits()) + let flags = orchard::bundle::Flags::from_byte(action_group.flags.bits()) .expect("type should not have unexpected bits"); - let instances = shielded_data + let instances = action_group .actions() .map(|action| { circuit::Instance::from_parts( @@ -164,7 +164,7 @@ impl From<&ShieldedData> for Item { Item { instances, - proof: orchard::circuit::Proof::new(shielded_data.proof.0.clone()), + proof: orchard::circuit::Proof::new(action_group.proof.0.clone()), } } } diff --git a/zebra-consensus/src/transaction.rs b/zebra-consensus/src/transaction.rs index 8c5a6d69c92..223315e7dcd 100644 --- a/zebra-consensus/src/transaction.rs +++ b/zebra-consensus/src/transaction.rs @@ -1136,6 +1136,7 @@ where let mut async_checks = AsyncChecks::new(); if let Some(orchard_shielded_data) = orchard_shielded_data { + // FIXME: update the comment to describe action groups // # Consensus // // > The proof 𝜋 MUST be valid given a primary input (cv, rt^{Orchard}, @@ -1147,13 +1148,15 @@ where // aggregated Halo2 proof per transaction, even with multiple // Actions in one transaction. So we queue it for verification // only once instead of queuing it up for every Action description. - async_checks.push( - V::get_verifier() - .clone() - .oneshot(primitives::halo2::Item::from(orchard_shielded_data)), - ); + for action_group in orchard_shielded_data.action_groups.iter() { + async_checks.push( + V::get_verifier() + .clone() + .oneshot(primitives::halo2::Item::from(action_group)), + ) + } - for authorized_action in orchard_shielded_data.actions.iter().cloned() { + for authorized_action in orchard_shielded_data.authorized_actions().cloned() { let (action, spend_auth_sig) = authorized_action.into_parts(); // # Consensus diff --git a/zebra-consensus/src/transaction/check.rs b/zebra-consensus/src/transaction/check.rs index 133c7e80470..1906c634ec1 100644 --- a/zebra-consensus/src/transaction/check.rs +++ b/zebra-consensus/src/transaction/check.rs @@ -172,7 +172,8 @@ pub fn coinbase_tx_no_prevout_joinsplit_spend(tx: &Transaction) -> Result<(), Tr return Err(TransactionError::CoinbaseHasSpend); } - if let Some(orchard_flags) = tx.orchard_flags() { + // FIXME: is it correct to use orchard_flags_union here? + if let Some(orchard_flags) = tx.orchard_flags_union() { if orchard_flags.contains(Flags::ENABLE_SPENDS) { return Err(TransactionError::CoinbaseHasEnableSpendsOrchard); } diff --git a/zebra-state/src/service/check/anchors.rs b/zebra-state/src/service/check/anchors.rs index b4a53c8f176..488d9361a76 100644 --- a/zebra-state/src/service/check/anchors.rs +++ b/zebra-state/src/service/check/anchors.rs @@ -88,9 +88,12 @@ fn sapling_orchard_anchors_refer_to_final_treestates( // > earlier block’s final Orchard treestate. // // - if let Some(shared_anchor) = transaction.orchard_shared_anchor() { + for (shared_anchor_index_in_tx, shared_anchor) in + transaction.orchard_shared_anchors().enumerate() + { tracing::debug!( ?shared_anchor, + ?shared_anchor_index_in_tx, ?tx_index_in_block, ?height, "observed orchard anchor", @@ -111,6 +114,7 @@ fn sapling_orchard_anchors_refer_to_final_treestates( tracing::debug!( ?shared_anchor, + ?shared_anchor_index_in_tx, ?tx_index_in_block, ?height, "validated orchard anchor", diff --git a/zebra-state/src/service/check/tests/nullifier.rs b/zebra-state/src/service/check/tests/nullifier.rs index 8a8b17e4fd0..a6c15832d9b 100644 --- a/zebra-state/src/service/check/tests/nullifier.rs +++ b/zebra-state/src/service/check/tests/nullifier.rs @@ -1134,9 +1134,11 @@ fn transaction_v5_with_orchard_shielded_data( if let Some(ref mut orchard_shielded_data) = orchard_shielded_data { // make sure there are no other nullifiers, by replacing all the authorized_actions - orchard_shielded_data.actions = authorized_actions.try_into().expect( - "unexpected invalid orchard::ShieldedData: must have at least one AuthorizedAction", - ); + // FIXME: works for V5 or V6 with a single action group only + orchard_shielded_data.action_groups.first_mut().actions = + authorized_actions.try_into().expect( + "unexpected invalid orchard::ShieldedData: must have at least one AuthorizedAction", + ); // set value balance to 0 to pass the chain value pool checks let zero_amount = 0.try_into().expect("unexpected invalid zero amount"); diff --git a/zebra-state/src/service/finalized_state/zebra_db/arbitrary.rs b/zebra-state/src/service/finalized_state/zebra_db/arbitrary.rs index 39bf082d43d..25b55e8e57f 100644 --- a/zebra-state/src/service/finalized_state/zebra_db/arbitrary.rs +++ b/zebra-state/src/service/finalized_state/zebra_db/arbitrary.rs @@ -66,7 +66,7 @@ impl ZebraDb { } // Orchard - if let Some(shared_anchor) = transaction.orchard_shared_anchor() { + for shared_anchor in transaction.orchard_shared_anchors() { batch.zs_insert(&orchard_anchors, shared_anchor, ()); } } diff --git a/zebrad/src/components/mempool/storage/tests/prop.rs b/zebrad/src/components/mempool/storage/tests/prop.rs index 3b7fd40467c..b4ee6029c3f 100644 --- a/zebrad/src/components/mempool/storage/tests/prop.rs +++ b/zebrad/src/components/mempool/storage/tests/prop.rs @@ -747,7 +747,10 @@ impl SpendConflictTestInput { conflicts: &HashSet, ) { if let Some(shielded_data) = maybe_shielded_data.take() { + // FIXME: works for V5 or V6 with a single action group only let updated_actions: Vec<_> = shielded_data + .action_groups + .first() .actions .into_vec() .into_iter() @@ -955,8 +958,14 @@ impl OrchardSpendConflict { orchard_shielded_data: &mut Option>, ) { if let Some(shielded_data) = orchard_shielded_data.as_mut() { - shielded_data.actions.first_mut().action.nullifier = - self.new_shielded_data.actions.first().action.nullifier; + // FIXME: works for V5 or V6 with a single action group only + shielded_data + .action_groups + .first_mut() + .actions + .first_mut() + .action + .nullifier = self.new_shielded_data.actions.first().action.nullifier; } else { *orchard_shielded_data = Some(self.new_shielded_data.0); } From 38f50f644cae9a59d9f2a78181b292579850f8b5 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 12:15:41 +0200 Subject: [PATCH 02/49] Fix zebrad test compilation errors --- .../components/mempool/storage/tests/prop.rs | 30 ++++++++----------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/zebrad/src/components/mempool/storage/tests/prop.rs b/zebrad/src/components/mempool/storage/tests/prop.rs index b4ee6029c3f..a1932cd534d 100644 --- a/zebrad/src/components/mempool/storage/tests/prop.rs +++ b/zebrad/src/components/mempool/storage/tests/prop.rs @@ -746,22 +746,18 @@ impl SpendConflictTestInput { maybe_shielded_data: &mut Option>, conflicts: &HashSet, ) { - if let Some(shielded_data) = maybe_shielded_data.take() { - // FIXME: works for V5 or V6 with a single action group only - let updated_actions: Vec<_> = shielded_data - .action_groups - .first() - .actions - .into_vec() - .into_iter() - .filter(|action| !conflicts.contains(&action.action.nullifier)) - .collect(); - - if let Ok(actions) = AtLeastOne::try_from(updated_actions) { - *maybe_shielded_data = Some(orchard::ShieldedData { - actions, - ..shielded_data - }); + if let Some(shielded_data) = maybe_shielded_data { + for action_group in shielded_data.action_groups.iter_mut() { + let updated_actions: Vec<_> = action_group + .actions + .clone() + .into_iter() + .filter(|action| !conflicts.contains(&action.action.nullifier)) + .collect(); + + if let Ok(actions) = AtLeastOne::try_from(updated_actions) { + action_group.actions = actions; + } } } } @@ -965,7 +961,7 @@ impl OrchardSpendConflict { .actions .first_mut() .action - .nullifier = self.new_shielded_data.actions.first().action.nullifier; + .nullifier = self.new_shielded_data.actions().next().action.nullifier; } else { *orchard_shielded_data = Some(self.new_shielded_data.0); } From 221d8bcaeb0ae07b8cd4b6e9b55297241fc1477e Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 16:30:19 +0200 Subject: [PATCH 03/49] Fix zebra-consensus tests compilation errors --- zebra-chain/src/orchard/shielded_data.rs | 2 +- zebra-consensus/src/primitives/halo2/tests.rs | 84 ++++++++++--------- zebra-consensus/src/transaction/tests.rs | 58 +++++++------ 3 files changed, 80 insertions(+), 64 deletions(-) diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index 68c29fc97d0..462d52fe1a4 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -47,7 +47,7 @@ pub struct ActionGroup { #[cfg(feature = "tx-v6")] /// Assets intended for burning /// Denoted as `vAssetBurn` in the spec (ZIP 230). - pub(crate) burn: FL::BurnType, + pub burn: FL::BurnType, } impl ActionGroup { diff --git a/zebra-consensus/src/primitives/halo2/tests.rs b/zebra-consensus/src/primitives/halo2/tests.rs index 2a379dc96f3..c3e8e5a9202 100644 --- a/zebra-consensus/src/primitives/halo2/tests.rs +++ b/zebra-consensus/src/primitives/halo2/tests.rs @@ -19,7 +19,7 @@ use rand::rngs::OsRng; use zebra_chain::{ orchard::{OrchardVanilla, ShieldedData}, - serialization::{ZcashDeserializeInto, ZcashSerialize}, + serialization::{AtLeastOne, ZcashDeserializeInto, ZcashSerialize}, }; use crate::primitives::halo2::*; @@ -71,37 +71,39 @@ fn generate_test_vectors() { .unwrap(); ShieldedData:: { - flags, + action_groups: AtLeastOne::from_one(ActionGroup { + flags, + shared_anchor: anchor_bytes.try_into().unwrap(), + proof: zebra_chain::primitives::Halo2Proof( + bundle.authorization().proof().as_ref().into(), + ), + actions: bundle + .actions() + .iter() + .map(|a| { + let action = zebra_chain::orchard::Action:: { + cv: a.cv_net().to_bytes().try_into().unwrap(), + nullifier: a.nullifier().to_bytes().try_into().unwrap(), + rk: <[u8; 32]>::from(a.rk()).into(), + cm_x: pallas::Base::from_repr(a.cmx().into()).unwrap(), + ephemeral_key: a.encrypted_note().epk_bytes.try_into().unwrap(), + enc_ciphertext: a.encrypted_note().enc_ciphertext.0.into(), + out_ciphertext: a.encrypted_note().out_ciphertext.into(), + }; + zebra_chain::orchard::shielded_data::AuthorizedAction { + action, + spend_auth_sig: <[u8; 64]>::from(a.authorization()).into(), + } + }) + .collect::>() + .try_into() + .unwrap(), + // FIXME: use a proper value when implementing V6 + #[cfg(feature = "tx-v6")] + burn: Default::default(), + }), value_balance: note_value.try_into().unwrap(), - shared_anchor: anchor_bytes.try_into().unwrap(), - proof: zebra_chain::primitives::Halo2Proof( - bundle.authorization().proof().as_ref().into(), - ), - actions: bundle - .actions() - .iter() - .map(|a| { - let action = zebra_chain::orchard::Action:: { - cv: a.cv_net().to_bytes().try_into().unwrap(), - nullifier: a.nullifier().to_bytes().try_into().unwrap(), - rk: <[u8; 32]>::from(a.rk()).into(), - cm_x: pallas::Base::from_repr(a.cmx().into()).unwrap(), - ephemeral_key: a.encrypted_note().epk_bytes.try_into().unwrap(), - enc_ciphertext: a.encrypted_note().enc_ciphertext.0.into(), - out_ciphertext: a.encrypted_note().out_ciphertext.into(), - }; - zebra_chain::orchard::shielded_data::AuthorizedAction { - action, - spend_auth_sig: <[u8; 64]>::from(a.authorization()).into(), - } - }) - .collect::>() - .try_into() - .unwrap(), binding_sig: <[u8; 64]>::from(bundle.authorization().binding_signature()).into(), - // FIXME: use a proper value when implementing V6 - #[cfg(feature = "tx-v6")] - burn: Default::default(), } }) .collect(); @@ -125,11 +127,13 @@ where let mut async_checks = FuturesUnordered::new(); for sd in shielded_data { - tracing::trace!(?sd); + for ag in sd.action_groups { + tracing::trace!(?ag); - let rsp = verifier.ready().await?.call(Item::from(&sd)); + let rsp = verifier.ready().await?.call(Item::from(&ag)); - async_checks.push(rsp); + async_checks.push(rsp); + } } while let Some(result) = async_checks.next().await { @@ -192,16 +196,18 @@ where let mut async_checks = FuturesUnordered::new(); for sd in shielded_data { - let mut sd = sd.clone(); + for ag in sd.action_groups { + let mut ag = ag.clone(); - sd.flags.remove(zebra_chain::orchard::Flags::ENABLE_SPENDS); - sd.flags.remove(zebra_chain::orchard::Flags::ENABLE_OUTPUTS); + ag.flags.remove(zebra_chain::orchard::Flags::ENABLE_SPENDS); + ag.flags.remove(zebra_chain::orchard::Flags::ENABLE_OUTPUTS); - tracing::trace!(?sd); + tracing::trace!(?ag); - let rsp = verifier.ready().await?.call(Item::from(&sd)); + let rsp = verifier.ready().await?.call(Item::from(&ag)); - async_checks.push(rsp); + async_checks.push(rsp); + } } while let Some(result) = async_checks.next().await { diff --git a/zebra-consensus/src/transaction/tests.rs b/zebra-consensus/src/transaction/tests.rs index 5494537edb8..f3b50ee1428 100644 --- a/zebra-consensus/src/transaction/tests.rs +++ b/zebra-consensus/src/transaction/tests.rs @@ -88,7 +88,7 @@ fn fake_v5_transaction_with_orchard_actions_has_inputs_and_outputs() { // If we add ENABLE_SPENDS flag it will pass the inputs check but fails with the outputs // TODO: Avoid new calls to `insert_fake_orchard_shielded_data` for each check #2409. let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; assert_eq!( check::has_inputs_and_outputs(&transaction), @@ -97,7 +97,7 @@ fn fake_v5_transaction_with_orchard_actions_has_inputs_and_outputs() { // If we add ENABLE_OUTPUTS flag it will pass the outputs check but fails with the inputs let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_OUTPUTS; + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_OUTPUTS; assert_eq!( check::has_inputs_and_outputs(&transaction), @@ -106,7 +106,7 @@ fn fake_v5_transaction_with_orchard_actions_has_inputs_and_outputs() { // Finally make it valid by adding both required flags let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS | zebra_chain::orchard::Flags::ENABLE_OUTPUTS; assert!(check::has_inputs_and_outputs(&transaction).is_ok()); @@ -141,17 +141,17 @@ fn fake_v5_transaction_with_orchard_actions_has_flags() { // If we add ENABLE_SPENDS flag it will pass. let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; assert!(check::has_enough_orchard_flags(&transaction).is_ok()); // If we add ENABLE_OUTPUTS flag instead, it will pass. let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_OUTPUTS; + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_OUTPUTS; assert!(check::has_enough_orchard_flags(&transaction).is_ok()); // If we add BOTH ENABLE_SPENDS and ENABLE_OUTPUTS flags it will pass. let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS | zebra_chain::orchard::Flags::ENABLE_OUTPUTS; assert!(check::has_enough_orchard_flags(&transaction).is_ok()); } @@ -840,7 +840,7 @@ fn v5_coinbase_transaction_with_enable_spends_flag_fails_validation() { let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS; assert_eq!( check::coinbase_tx_no_prevout_joinsplit_spend(&transaction), @@ -2418,14 +2418,18 @@ fn v5_with_duplicate_orchard_action() { let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); // Enable spends - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS | zebra_chain::orchard::Flags::ENABLE_OUTPUTS; // Duplicate the first action - let duplicate_action = shielded_data.actions.first().clone(); + let duplicate_action = shielded_data.action_groups.first().actions.first().clone(); let duplicate_nullifier = duplicate_action.action.nullifier; - shielded_data.actions.push(duplicate_action); + shielded_data + .action_groups + .first_mut() + .actions + .push(duplicate_action); // Initialize the verifier let state_service = @@ -2867,15 +2871,18 @@ fn coinbase_outputs_are_decryptable_for_fake_v5_blocks() { .expect("At least one fake V5 transaction with no inputs and no outputs"); let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS | zebra_chain::orchard::Flags::ENABLE_OUTPUTS; - let action = - fill_action_with_note_encryption_test_vector(&shielded_data.actions[0].action, v); - let sig = shielded_data.actions[0].spend_auth_sig; - shielded_data.actions = vec![AuthorizedAction::from_parts(action, sig)] - .try_into() - .unwrap(); + let action = fill_action_with_note_encryption_test_vector( + &shielded_data.action_groups.first().actions[0].action, + v, + ); + let sig = shielded_data.action_groups.first().actions[0].spend_auth_sig; + shielded_data.action_groups.first_mut().actions = + vec![AuthorizedAction::from_parts(action, sig)] + .try_into() + .unwrap(); assert_eq!( check::coinbase_outputs_are_decryptable( @@ -2909,15 +2916,18 @@ fn shielded_outputs_are_not_decryptable_for_fake_v5_blocks() { .expect("At least one fake V5 transaction with no inputs and no outputs"); let shielded_data = insert_fake_orchard_shielded_data(&mut transaction); - shielded_data.flags = zebra_chain::orchard::Flags::ENABLE_SPENDS + shielded_data.action_groups.first_mut().flags = zebra_chain::orchard::Flags::ENABLE_SPENDS | zebra_chain::orchard::Flags::ENABLE_OUTPUTS; - let action = - fill_action_with_note_encryption_test_vector(&shielded_data.actions[0].action, v); - let sig = shielded_data.actions[0].spend_auth_sig; - shielded_data.actions = vec![AuthorizedAction::from_parts(action, sig)] - .try_into() - .unwrap(); + let action = fill_action_with_note_encryption_test_vector( + &shielded_data.action_groups.first().actions[0].action, + v, + ); + let sig = shielded_data.action_groups.first().actions[0].spend_auth_sig; + shielded_data.action_groups.first_mut().actions = + vec![AuthorizedAction::from_parts(action, sig)] + .try_into() + .unwrap(); assert_eq!( check::coinbase_outputs_are_decryptable( From d8cd8199ab7f9f386c5ad21069f47856ae6be776 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 16:52:17 +0200 Subject: [PATCH 04/49] Fix zebrad tests compilation errors --- zebrad/src/components/mempool/storage/tests/prop.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/zebrad/src/components/mempool/storage/tests/prop.rs b/zebrad/src/components/mempool/storage/tests/prop.rs index a1932cd534d..3914d74001c 100644 --- a/zebrad/src/components/mempool/storage/tests/prop.rs +++ b/zebrad/src/components/mempool/storage/tests/prop.rs @@ -961,7 +961,12 @@ impl OrchardSpendConflict { .actions .first_mut() .action - .nullifier = self.new_shielded_data.actions().next().action.nullifier; + .nullifier = self + .new_shielded_data + .actions() + .next() + .expect("at least one action") + .nullifier; } else { *orchard_shielded_data = Some(self.new_shielded_data.0); } From 518fa234e47353455d41461569f7e594f1a33199 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 17:33:54 +0200 Subject: [PATCH 05/49] Fix cargo clippy error --- zebra-chain/src/orchard/shielded_data.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index 462d52fe1a4..b969f33b137 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -198,7 +198,7 @@ impl ShieldedData { pub fn shared_anchors(&self) -> impl Iterator + '_ { self.action_groups .iter() - .map(|action_group| action_group.shared_anchor.clone()) + .map(|action_group| action_group.shared_anchor) } /// Iterate over the [`AuthorizedAction`]s in this From d9305da70591fc029880e9da855c1cb1e2b8d557 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Thu, 3 Apr 2025 18:36:49 +0200 Subject: [PATCH 06/49] Minor fixes in comments --- zebra-chain/src/orchard/shielded_data.rs | 7 ++++--- zebra-chain/src/transaction/serialize.rs | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index b969f33b137..31613763ac2 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -22,8 +22,8 @@ use crate::{ use super::{OrchardVanilla, ShieldedDataFlavor}; -// FIXME: wrap all ActionGroup usages withj tx-v6 feature flag? -/// FIXME: add doc +// FIXME: wrap all ActionGroup usages with tx-v6 feature flag? +/// Action Group description. #[cfg(feature = "tx-v6")] #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)] #[serde(bound( @@ -65,7 +65,8 @@ impl ActionGroup { deserialize = "FL::BurnType: serde::Deserialize<'de>" ))] pub struct ShieldedData { - /// FIXME: add doc + /// Action Group descriptions. + /// Denoted as `vActionGroupsOrchard` in the spec (ZIP 230). pub action_groups: AtLeastOne>, /// Denoted as `valueBalanceOrchard` in the spec. pub value_balance: Amount, diff --git a/zebra-chain/src/transaction/serialize.rs b/zebra-chain/src/transaction/serialize.rs index 8a60d105807..ca958fcb493 100644 --- a/zebra-chain/src/transaction/serialize.rs +++ b/zebra-chain/src/transaction/serialize.rs @@ -541,7 +541,7 @@ impl ZcashDeserialize for Option> { fn zcash_deserialize(mut reader: R) -> Result { // FIXME: Implement deserialization of multiple action groups (under a feature flag) - // Denoted as `nActionGroupsOrchard` in the spec (ZIP 230) (must be one for V6/NU7). + // Denoted as `nActionGroupsOrchard` in the spec (ZIP 230) (must be one for V6/NU7). let n_action_groups: usize = (&mut reader) .zcash_deserialize_into::()? .into(); From 5612c75ade0516f8a9c81b46cbf710d2cf6dd372 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Fri, 4 Apr 2025 12:38:40 +0200 Subject: [PATCH 07/49] Add support of serialization of multiple action groups (use new zsa-swap feature flag to enable) --- zebra-chain/Cargo.toml | 4 + zebra-chain/src/transaction/serialize.rs | 197 +++++++++++++---------- zebra-consensus/Cargo.toml | 7 + zebra-state/Cargo.toml | 6 + zebrad/Cargo.toml | 8 + 5 files changed, 138 insertions(+), 84 deletions(-) diff --git a/zebra-chain/Cargo.toml b/zebra-chain/Cargo.toml index 4d0ff8e272f..fbc5f0e059e 100644 --- a/zebra-chain/Cargo.toml +++ b/zebra-chain/Cargo.toml @@ -17,6 +17,7 @@ categories = ["asynchronous", "cryptography::cryptocurrencies", "encoding"] [features] #default = [] default = ["tx-v6"] +#default = ["tx-v6", "zsa-swap"] # Production features that activate extra functionality @@ -67,6 +68,9 @@ tx-v6 = [ "nonempty" ] +# Support for ZSA asset swaps +zsa-swap = [] + [dependencies] # Cryptography diff --git a/zebra-chain/src/transaction/serialize.rs b/zebra-chain/src/transaction/serialize.rs index ca958fcb493..96cbbf4d50d 100644 --- a/zebra-chain/src/transaction/serialize.rs +++ b/zebra-chain/src/transaction/serialize.rs @@ -356,7 +356,7 @@ impl ZcashSerialize for orchard::ShieldedData { fn zcash_serialize(&self, mut writer: W) -> Result<(), io::Error> { assert!( self.action_groups.len() == 1, - "only one action group is supported for transaction V5" + "V6 transaction must contain exactly one action group" ); let action_group = self.action_groups.first(); @@ -402,52 +402,60 @@ impl ZcashSerialize for orchard::ShieldedData { #[allow(clippy::unwrap_in_result)] impl ZcashSerialize for orchard::ShieldedData { fn zcash_serialize(&self, mut writer: W) -> Result<(), io::Error> { - // FIXME: Implement serialization of multiple action groups (under a feature flag) - + #[cfg(not(feature = "zsa-swap"))] assert!( self.action_groups.len() == 1, "V6 transaction must contain exactly one action group" ); - let action_group = self.action_groups.first(); + // FIXME: consider using use zcash_serialize_external_count for or Vec::zcash_serialize + for action_group in self.action_groups.iter() { + // Denoted as `nActionGroupsOrchard` in the spec (ZIP 230) (must be one for V6/NU7). + CompactSizeMessage::try_from(self.action_groups.len()) + .expect("nActionGroupsOrchard should convert to CompactSizeMessage") + .zcash_serialize(&mut writer)?; - // Denoted as `nActionGroupsOrchard` in the spec (ZIP 230) (must be one for V6/NU7). - CompactSizeMessage::try_from(self.action_groups.len()) - .expect("nActionGroupsOrchard should convert to CompactSizeMessage") - .zcash_serialize(&mut writer)?; + // Split the AuthorizedAction + let (actions, sigs): (Vec>, Vec>) = + action_group + .actions + .iter() + .cloned() + .map(orchard::AuthorizedAction::into_parts) + .unzip(); - // Split the AuthorizedAction - let (actions, sigs): (Vec>, Vec>) = - action_group - .actions - .iter() - .cloned() - .map(orchard::AuthorizedAction::into_parts) - .unzip(); + // Denoted as `nActionsOrchard` and `vActionsOrchard` in the spec. + actions.zcash_serialize(&mut writer)?; - // Denoted as `nActionsOrchard` and `vActionsOrchard` in the spec. - actions.zcash_serialize(&mut writer)?; + // Denoted as `flagsOrchard` in the spec. + action_group.flags.zcash_serialize(&mut writer)?; - // Denoted as `flagsOrchard` in the spec. - action_group.flags.zcash_serialize(&mut writer)?; + // Denoted as `anchorOrchard` in the spec. + action_group.shared_anchor.zcash_serialize(&mut writer)?; - // Denoted as `anchorOrchard` in the spec. - action_group.shared_anchor.zcash_serialize(&mut writer)?; + // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. + action_group.proof.zcash_serialize(&mut writer)?; - // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. - action_group.proof.zcash_serialize(&mut writer)?; + // Denoted as `nAGExpiryHeight` in the spec (ZIP 230) (must be zero for V6/NU7). + writer.write_u32::(0)?; - // Denoted as `nAGExpiryHeight` in the spec (ZIP 230) (must be zero for V6/NU7). - writer.write_u32::(0)?; + // Denoted as `vAssetBurn` in the spec (ZIP 230). + #[cfg(feature = "zsa-swap")] + action_group.burn.zcash_serialize(&mut writer)?; - // Denoted as `vSpendAuthSigsOrchard` in the spec. - zcash_serialize_external_count(&sigs, &mut writer)?; + // Denoted as `vSpendAuthSigsOrchard` in the spec. + zcash_serialize_external_count(&sigs, &mut writer)?; + } // Denoted as `valueBalanceOrchard` in the spec. self.value_balance.zcash_serialize(&mut writer)?; // Denoted as `vAssetBurn` in the spec (ZIP 230). - action_group.burn.zcash_serialize(&mut writer)?; + #[cfg(not(feature = "zsa-swap"))] + self.action_groups + .first() + .burn + .zcash_serialize(&mut writer)?; // Denoted as `bindingSigOrchard` in the spec. self.binding_sig.zcash_serialize(&mut writer)?; @@ -545,82 +553,103 @@ impl ZcashDeserialize for Option> { let n_action_groups: usize = (&mut reader) .zcash_deserialize_into::()? .into(); + if n_action_groups == 0 { return Ok(None); - } else if n_action_groups != 1 { + } + + #[cfg(not(feature = "zsa-swap"))] + if n_action_groups != 1 { return Err(SerializationError::Parse( "V6 transaction must contain exactly one action group", )); } - // Denoted as `nActionsOrchard` and `vActionsOrchard` in the spec. - let actions: Vec> = (&mut reader).zcash_deserialize_into()?; - - // # Consensus - // - // > Elements of an Action description MUST be canonical encodings of the types given above. - // - // https://zips.z.cash/protocol/protocol.pdf#actiondesc - // - // Some Action elements are validated in this function; they are described below. - - // Denoted as `flagsOrchard` in the spec. - // Consensus: type of each flag is 𝔹, i.e. a bit. This is enforced implicitly - // in [`Flags::zcash_deserialized`]. - let flags: orchard::Flags = (&mut reader).zcash_deserialize_into()?; + let mut action_groups = Vec::with_capacity(n_action_groups); + + // FIXME: use zcash_deserialize_external_count for or Vec::zcash_deserialize for allocation safety + for _ in 0..n_action_groups { + // Denoted as `nActionsOrchard` and `vActionsOrchard` in the spec. + let actions: Vec> = + (&mut reader).zcash_deserialize_into()?; + + // # Consensus + // + // > Elements of an Action description MUST be canonical encodings of the types given above. + // + // https://zips.z.cash/protocol/protocol.pdf#actiondesc + // + // Some Action elements are validated in this function; they are described below. + + // Denoted as `flagsOrchard` in the spec. + // Consensus: type of each flag is 𝔹, i.e. a bit. This is enforced implicitly + // in [`Flags::zcash_deserialized`]. + let flags: orchard::Flags = (&mut reader).zcash_deserialize_into()?; + + // Denoted as `anchorOrchard` in the spec. + // Consensus: type is `{0 .. 𝑞_ℙ − 1}`. See [`orchard::tree::Root::zcash_deserialize`]. + let shared_anchor: orchard::tree::Root = (&mut reader).zcash_deserialize_into()?; + + // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. + // Consensus: type is `ZKAction.Proof`, i.e. a byte sequence. + // https://zips.z.cash/protocol/protocol.pdf#halo2encoding + let proof: Halo2Proof = (&mut reader).zcash_deserialize_into()?; + + // Denoted as `nAGExpiryHeight` in the spec (ZIP 230) (must be zero for V6/NU7). + let n_ag_expiry_height = reader.read_u32::()?; + if n_ag_expiry_height != 0 { + return Err(SerializationError::Parse("nAGExpiryHeight for V6/NU7")); + } - // Denoted as `anchorOrchard` in the spec. - // Consensus: type is `{0 .. 𝑞_ℙ − 1}`. See [`orchard::tree::Root::zcash_deserialize`]. - let shared_anchor: orchard::tree::Root = (&mut reader).zcash_deserialize_into()?; + // Denoted as `vAssetBurn` in the spec (ZIP 230). + #[cfg(feature = "zsa-swap")] + let burn = (&mut reader).zcash_deserialize_into()?; + #[cfg(not(feature = "zsa-swap"))] + let burn = Default::default(); + + // Denoted as `vSpendAuthSigsOrchard` in the spec. + // Consensus: this validates the `spendAuthSig` elements, whose type is + // SpendAuthSig^{Orchard}.Signature, i.e. + // B^Y^{[ceiling(ℓ_G/8) + ceiling(bitlength(𝑟_G)/8)]} i.e. 64 bytes + // See [`Signature::zcash_deserialize`]. + let sigs: Vec> = + zcash_deserialize_external_count(actions.len(), &mut reader)?; + + // Create the AuthorizedAction from deserialized parts + let authorized_actions: Vec> = actions + .into_iter() + .zip(sigs) + .map(|(action, spend_auth_sig)| { + orchard::AuthorizedAction::from_parts(action, spend_auth_sig) + }) + .collect(); - // Denoted as `sizeProofsOrchard` and `proofsOrchard` in the spec. - // Consensus: type is `ZKAction.Proof`, i.e. a byte sequence. - // https://zips.z.cash/protocol/protocol.pdf#halo2encoding - let proof: Halo2Proof = (&mut reader).zcash_deserialize_into()?; + let actions: AtLeastOne> = + authorized_actions.try_into()?; - // Denoted as `nAGExpiryHeight` in the spec (ZIP 230) (must be zero for V6/NU7). - let n_ag_expiry_height = reader.read_u32::()?; - if n_ag_expiry_height != 0 { - return Err(SerializationError::Parse("nAGExpiryHeight for V6/NU7")); + action_groups.push(ActionGroup { + flags, + shared_anchor, + proof, + actions, + burn, + }) } - // Denoted as `vSpendAuthSigsOrchard` in the spec. - // Consensus: this validates the `spendAuthSig` elements, whose type is - // SpendAuthSig^{Orchard}.Signature, i.e. - // B^Y^{[ceiling(ℓ_G/8) + ceiling(bitlength(𝑟_G)/8)]} i.e. 64 bytes - // See [`Signature::zcash_deserialize`]. - let sigs: Vec> = - zcash_deserialize_external_count(actions.len(), &mut reader)?; - // Denoted as `valueBalanceOrchard` in the spec. let value_balance: amount::Amount = (&mut reader).zcash_deserialize_into()?; // Denoted as `vAssetBurn` in the spec (ZIP 230). - let burn = (&mut reader).zcash_deserialize_into()?; + #[cfg(not(feature = "zsa-swap"))] + { + action_groups[0].burn = (&mut reader).zcash_deserialize_into()?; + } // Denoted as `bindingSigOrchard` in the spec. let binding_sig: Signature = (&mut reader).zcash_deserialize_into()?; - // Create the AuthorizedAction from deserialized parts - let authorized_actions: Vec> = actions - .into_iter() - .zip(sigs) - .map(|(action, spend_auth_sig)| { - orchard::AuthorizedAction::from_parts(action, spend_auth_sig) - }) - .collect(); - - let actions: AtLeastOne> = - authorized_actions.try_into()?; - Ok(Some(orchard::ShieldedData:: { - action_groups: AtLeastOne::from_one(ActionGroup { - flags, - shared_anchor, - proof, - actions, - burn, - }), + action_groups: action_groups.try_into()?, value_balance, binding_sig, })) diff --git a/zebra-consensus/Cargo.toml b/zebra-consensus/Cargo.toml index 05211f296ac..5268b5657fb 100644 --- a/zebra-consensus/Cargo.toml +++ b/zebra-consensus/Cargo.toml @@ -17,6 +17,7 @@ categories = ["asynchronous", "cryptography::cryptocurrencies"] [features] #default = [] default = ["tx-v6"] +#default = ["tx-v6", "zsa-swap"] # Production features that activate extra dependencies, or extra features in dependencies @@ -41,6 +42,12 @@ tx-v6 = [ "zebra-chain/tx-v6" ] +# Support for ZSA asset swaps +zsa-swap = [ + "zebra-state/zsa-swap", + "zebra-chain/zsa-swap" +] + [dependencies] blake2b_simd = "1.0.2" bellman = "0.14.0" diff --git a/zebra-state/Cargo.toml b/zebra-state/Cargo.toml index 45dcf9e96c6..1dff5cd3eb4 100644 --- a/zebra-state/Cargo.toml +++ b/zebra-state/Cargo.toml @@ -17,6 +17,7 @@ categories = ["asynchronous", "caching", "cryptography::cryptocurrencies"] [features] #default = [] default = ["tx-v6"] +#default = ["tx-v6", "zsa-swap"] # Production features that activate extra dependencies, or extra features in dependencies @@ -52,6 +53,11 @@ tx-v6 = [ "zebra-chain/tx-v6" ] +# Support for ZSA asset swaps +zsa-swap = [ + "zebra-chain/zsa-swap" +] + [dependencies] bincode = "1.3.3" chrono = { version = "0.4.38", default-features = false, features = ["clock", "std"] } diff --git a/zebrad/Cargo.toml b/zebrad/Cargo.toml index fc1c8d4a889..e260658c87a 100644 --- a/zebrad/Cargo.toml +++ b/zebrad/Cargo.toml @@ -54,6 +54,7 @@ features = [ # In release builds, don't compile debug logging code, to improve performance. #default = ["release_max_level_info", "progress-bar", "getblocktemplate-rpcs"] default = ["release_max_level_info", "progress-bar", "getblocktemplate-rpcs", "tx-v6"] +#default = ["release_max_level_info", "progress-bar", "getblocktemplate-rpcs", "tx-v6", "zsa-swap"] # Default features for official ZF binary release builds default-release-binaries = ["default", "sentry"] @@ -164,6 +165,13 @@ tx-v6 = [ "zebra-chain/tx-v6" ] +# Support for ZSA asset swaps +zsa-swap = [ + "zebra-consensus/zsa-swap", + "zebra-state/zsa-swap", + "zebra-chain/zsa-swap" +] + [dependencies] zebra-chain = { path = "../zebra-chain", version = "1.0.0-beta.41" } zebra-consensus = { path = "../zebra-consensus", version = "1.0.0-beta.41" } From adfa962256746ab9861fb8dbb4d8e022874ffe46 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 28 May 2025 13:04:39 +0200 Subject: [PATCH 08/49] Create push-deploy.yaml on zsa-integration-consensus --- .github/workflows/push-deploy.yaml | 58 ++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 .github/workflows/push-deploy.yaml diff --git a/.github/workflows/push-deploy.yaml b/.github/workflows/push-deploy.yaml new file mode 100644 index 00000000000..12d1bed16ea --- /dev/null +++ b/.github/workflows/push-deploy.yaml @@ -0,0 +1,58 @@ +# This GitHub Actions workflow automates the deployment of the Zebra Server to Amazon ECS. +# It triggers on any new tag, builds a Docker image, pushes it to Amazon Elastic Container Registry (ECR), and updates the specified ECS service to use the latest image. +name: Deploy to Amazon ECS + +on: + push: + tags: + - '*' # Triggers the workflow on any new tag + workflow_dispatch: # Allows manual triggering + +env: + AWS_REGION: ${{ vars.AWS_REGION || 'eu-central-1' }} + ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY || 'dev-zebra-server' }} + ECS_SERVICE: ${{ vars.ECS_SERVICE || 'dev-zebra' }} + ECS_CLUSTER: ${{ vars.ECS_CLUSTER || 'dev-zebra-cluster' }} + +jobs: + push-deploy: + name: Push and Deploy + runs-on: ubuntu-latest + environment: production + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Configure AWS credentials + uses: aws-actions/configure-aws-credentials@v4 + with: + aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} + aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + aws-region: ${{ env.AWS_REGION }} + + - name: Login to Amazon ECR + id: login-ecr + uses: aws-actions/amazon-ecr-login@v2 + + - name: Get short commit hash + id: vars + run: echo "SHORT_SHA=$(git rev-parse --short HEAD)" >> $GITHUB_ENV + + - name: Build, tag, and push image to Amazon ECR + id: build-image + env: + ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }} + IMAGE_TAG_LATEST: latest + IMAGE_TAG_COMMIT: ${{ env.SHORT_SHA }} + run: | + # Build a docker container + docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT -f testnet-single-node-deploy/dockerfile . + + # Push both tags to ECR + docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST + docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT + + # Output the image URIs + echo "image_latest=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST" >> $GITHUB_OUTPUT + echo "image_commit=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT" >> $GITHUB_OUTPUT From aab80b18e9fdfb0dc39d680a2b201e778ca994e7 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 28 May 2025 13:09:54 +0200 Subject: [PATCH 09/49] Create dockerfile --- testnet-single-node-deploy /dockerfile | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 testnet-single-node-deploy /dockerfile diff --git a/testnet-single-node-deploy /dockerfile b/testnet-single-node-deploy /dockerfile new file mode 100644 index 00000000000..3d457cb2fcb --- /dev/null +++ b/testnet-single-node-deploy /dockerfile @@ -0,0 +1,17 @@ +# Use Rust 1.81.0 as the base image +FROM rust:1.81.0 + +# Install required dependencies +RUN apt-get update && apt-get install -y git build-essential clangq + +# Copy the entire project, except whats defined in .dockerignore +COPY . . + +# Build the 'zebrad' binary with the 'getblocktemplate-rpcs' feature enabled +RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" + +# Expose the default Zebra node RPC port +EXPOSE 18232 + +# Set the entrypoint +ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From 0e7199a190eac81276ae34307f0be37e8d83b185 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 28 May 2025 13:10:42 +0200 Subject: [PATCH 10/49] Rename dockerfile to dockerfile --- .../dockerfile | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {testnet-single-node-deploy => testnet-single-node-deploy}/dockerfile (100%) diff --git a/testnet-single-node-deploy /dockerfile b/testnet-single-node-deploy/dockerfile similarity index 100% rename from testnet-single-node-deploy /dockerfile rename to testnet-single-node-deploy/dockerfile From e1c2413d15825a9b62bfce9d679f5d9d19b25c61 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 28 May 2025 13:16:02 +0200 Subject: [PATCH 11/49] Change clangq to clang --- testnet-single-node-deploy/dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 3d457cb2fcb..316d251f952 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -2,7 +2,7 @@ FROM rust:1.81.0 # Install required dependencies -RUN apt-get update && apt-get install -y git build-essential clangq +RUN apt-get update && apt-get install -y git build-essential clang # Copy the entire project, except whats defined in .dockerignore COPY . . From d65847435f938e6c6ddeb536653c31ffd10ac89d Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Tue, 15 Jul 2025 12:38:28 +0200 Subject: [PATCH 12/49] Create push-ecr.yaml --- .github/workflows/push-ecr.yaml | 119 ++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 .github/workflows/push-ecr.yaml diff --git a/.github/workflows/push-ecr.yaml b/.github/workflows/push-ecr.yaml new file mode 100644 index 00000000000..6e38c2ac0dd --- /dev/null +++ b/.github/workflows/push-ecr.yaml @@ -0,0 +1,119 @@ +# This GitHub Actions workflow automates pushing the Zebra Server Docker image to Amazon ECR. +# It triggers on any new tag or manual dispatch, builds a Docker image, and pushes it to Amazon Elastic Container Registry (ECR). +name: Push to Amazon ECR + +on: + push: + tags: + - '*' # Triggers the workflow on any new tag + workflow_dispatch: + inputs: + image_tag_version: + description: 'Version to tag the Docker image' + required: false + type: string + +env: + AWS_REGION: ${{ vars.AWS_REGION || 'eu-central-1' }} + ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY || 'dev-zebra-server' }} + DOCKERFILE_PATH: ${{ vars.DOCKERFILE_PATH }} + +jobs: + push-to-ecr: + name: Push to ECR + runs-on: ubuntu-latest + environment: production + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Configure AWS credentials + uses: aws-actions/configure-aws-credentials@v4 + with: + aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} + aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + aws-region: ${{ env.AWS_REGION }} + + - name: Login to Amazon ECR + id: login-ecr + uses: aws-actions/amazon-ecr-login@v2 + + - name: Get Git tags and set image tags + id: vars + run: | + git fetch --tags + + # Get exact match tag if it exists (will be empty if the current commit doesn't have a tag) + GIT_TAG=$(git describe --exact-match --tags 2>/dev/null || echo "") + + # Set environment variables and echo results + if [ -n "$GIT_TAG" ]; then + echo "GIT_TAG=$GIT_TAG" >> $GITHUB_ENV + echo "Git Tag Discovery:" + echo " Found exact match Git tag: $GIT_TAG" + else + echo "Git Tag Discovery:" + echo " No exact match Git tag found for current commit" + fi + + # Set the input IMAGE_TAG_VERSION + echo "IMAGE_TAG_VERSION=${{ github.event.inputs.image_tag_version }}" >> $GITHUB_ENV + echo " User-provided IMAGE_TAG_VERSION: ${{ github.event.inputs.image_tag_version }}" + + - name: Build, tag, and push image to Amazon ECR + id: build-image + env: + ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }} + IMAGE_TAG_LATEST: latest + run: | + # Build docker container with multiple tags + DOCKER_BUILD_ARGS=() + DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST") + DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION") + + # Add exact tag if it exists + if [ -n "$GIT_TAG" ]; then + DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$GIT_TAG") + fi + + # Echo final tags that will be pushed + echo "Docker Image Tags to be pushed:" + for arg in "${DOCKER_BUILD_ARGS[@]}"; do + if [[ "$arg" != "-t" ]]; then + echo " $arg" + fi + done + echo "" + + # Build with all tags + echo "Building Docker image..." + docker build "${DOCKER_BUILD_ARGS[@]}" -f $DOCKERFILE_PATH . + + # Push all tags with error handling + for tag in "$IMAGE_TAG_LATEST" "$IMAGE_TAG_VERSION" "$GIT_TAG"; do + # Skip empty tags (e.g., if GIT_TAG is unset) + [ -z "$tag" ] && continue + + image="$ECR_REGISTRY/$ECR_REPOSITORY:$tag" + echo "Pushing $image…" + if ! docker push "$image"; then + echo "Failed to push $image" + exit 1 + fi + done + + # Output the image URIs + echo "image_latest=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST" >> $GITHUB_OUTPUT + echo "image_version=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION" >> $GITHUB_OUTPUT + + if [ -n "$GIT_TAG" ]; then + echo "image_exact_tag=$ECR_REGISTRY/$ECR_REPOSITORY:$GIT_TAG" >> $GITHUB_OUTPUT + fi + + # Print the public repository URL + echo "" + echo "=====================================" + echo "Public ECR Repository URL:" + echo "https://gallery.ecr.aws/$ECR_REPOSITORY" + echo "=====================================" From 0001f7fe37a290d11038e71efe7dc5b5df7a5626 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Tue, 15 Jul 2025 12:41:01 +0200 Subject: [PATCH 13/49] Add ecs and remove old workflow --- .github/workflows/deploy-ecs.yaml | 97 ++++++++++++++++++++++++++++++ .github/workflows/push-deploy.yaml | 58 ------------------ 2 files changed, 97 insertions(+), 58 deletions(-) create mode 100644 .github/workflows/deploy-ecs.yaml delete mode 100644 .github/workflows/push-deploy.yaml diff --git a/.github/workflows/deploy-ecs.yaml b/.github/workflows/deploy-ecs.yaml new file mode 100644 index 00000000000..7c735274ab0 --- /dev/null +++ b/.github/workflows/deploy-ecs.yaml @@ -0,0 +1,97 @@ +# This GitHub Actions workflow automates deploying the Zebra Server to Amazon ECS. +# It allows manual triggering with the ability to choose which image tag to deploy. +# Because of the "force-new-deployment" flag, the ECS service will update to a new 'latest' image, if one was pushed. +name: Deploy to Amazon ECS + +on: + workflow_dispatch: + inputs: + image_tag: + description: 'Docker image tag to deploy (e.g., latest, v1.0.0, commit-hash)' + required: true + type: string + default: 'latest' + +env: + AWS_REGION: ${{ vars.AWS_REGION || 'eu-central-1' }} + ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY || 'dev-zebra-server' }} + ECS_SERVICE: ${{ vars.ECS_SERVICE || 'dev-zebra' }} + ECS_CLUSTER: ${{ vars.ECS_CLUSTER || 'dev-zebra-cluster' }} + +jobs: + deploy-to-ecs: + name: Deploy to ECS + runs-on: ubuntu-latest + environment: production + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Configure AWS credentials + uses: aws-actions/configure-aws-credentials@v4 + with: + aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} + aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + aws-region: ${{ env.AWS_REGION }} + + - name: Login to Amazon ECR + id: login-ecr + uses: aws-actions/amazon-ecr-login@v2 + + - name: Deploy to Amazon ECS + id: deploy-ecs + env: + ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }} + IMAGE_TAG: ${{ github.event.inputs.image_tag }} + run: | + # Construct the full image URI + IMAGE_URI="$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG" + + echo "Deploying image: $IMAGE_URI" + echo "ECS Service: $ECS_SERVICE" + echo "ECS Cluster: $ECS_CLUSTER" + + # Update the ECS service with the new image + aws ecs update-service \ + --cluster $ECS_CLUSTER \ + --service $ECS_SERVICE \ + --force-new-deployment + + # Wait for the service to be stable + echo "Waiting for ECS service to be stable..." + aws ecs wait services-stable \ + --cluster $ECS_CLUSTER \ + --services $ECS_SERVICE + + # Check the actual service status after waiting + echo "Checking service status..." + SERVICE_STATUS=$(aws ecs describe-services \ + --cluster $ECS_CLUSTER \ + --services $ECS_SERVICE \ + --query 'services[0].status' \ + --output text) + + echo "Service Status: $SERVICE_STATUS" + + # Check if deployment was successful + if [ "$SERVICE_STATUS" = "ACTIVE" ]; then + echo "Deployment completed successfully!" + else + echo "Deployment may have issues. Service status: $SERVICE_STATUS" + exit 1 + fi + + # Output the deployment information + echo "deployed_image=$IMAGE_URI" >> $GITHUB_OUTPUT + echo "ecs_service=$ECS_SERVICE" >> $GITHUB_OUTPUT + echo "ecs_cluster=$ECS_CLUSTER" >> $GITHUB_OUTPUT + + - name: Get deployment status + run: | + echo "Deployment Status:" + aws ecs describe-services \ + --cluster $ECS_CLUSTER \ + --services $ECS_SERVICE \ + --query 'services[0].{ServiceName:serviceName,Status:status,DesiredCount:desiredCount,RunningCount:runningCount,PendingCount:pendingCount}' \ + --output table diff --git a/.github/workflows/push-deploy.yaml b/.github/workflows/push-deploy.yaml deleted file mode 100644 index 12d1bed16ea..00000000000 --- a/.github/workflows/push-deploy.yaml +++ /dev/null @@ -1,58 +0,0 @@ -# This GitHub Actions workflow automates the deployment of the Zebra Server to Amazon ECS. -# It triggers on any new tag, builds a Docker image, pushes it to Amazon Elastic Container Registry (ECR), and updates the specified ECS service to use the latest image. -name: Deploy to Amazon ECS - -on: - push: - tags: - - '*' # Triggers the workflow on any new tag - workflow_dispatch: # Allows manual triggering - -env: - AWS_REGION: ${{ vars.AWS_REGION || 'eu-central-1' }} - ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY || 'dev-zebra-server' }} - ECS_SERVICE: ${{ vars.ECS_SERVICE || 'dev-zebra' }} - ECS_CLUSTER: ${{ vars.ECS_CLUSTER || 'dev-zebra-cluster' }} - -jobs: - push-deploy: - name: Push and Deploy - runs-on: ubuntu-latest - environment: production - - steps: - - name: Checkout - uses: actions/checkout@v4 - - - name: Configure AWS credentials - uses: aws-actions/configure-aws-credentials@v4 - with: - aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} - aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} - aws-region: ${{ env.AWS_REGION }} - - - name: Login to Amazon ECR - id: login-ecr - uses: aws-actions/amazon-ecr-login@v2 - - - name: Get short commit hash - id: vars - run: echo "SHORT_SHA=$(git rev-parse --short HEAD)" >> $GITHUB_ENV - - - name: Build, tag, and push image to Amazon ECR - id: build-image - env: - ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }} - IMAGE_TAG_LATEST: latest - IMAGE_TAG_COMMIT: ${{ env.SHORT_SHA }} - run: | - # Build a docker container - docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT -f testnet-single-node-deploy/dockerfile . - - # Push both tags to ECR - docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST - docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT - - # Output the image URIs - echo "image_latest=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST" >> $GITHUB_OUTPUT - echo "image_commit=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_COMMIT" >> $GITHUB_OUTPUT From c89448cdc451143c33ff4b2e1fa8a2d7ccf17147 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 21 Jul 2025 10:19:11 +0200 Subject: [PATCH 14/49] Add version logs --- zebrad/build.rs | 20 ++++++++++++++++++++ zebrad/src/application.rs | 2 ++ 2 files changed, 22 insertions(+) diff --git a/zebrad/build.rs b/zebrad/build.rs index efac0a69774..1e5df1a7626 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -6,6 +6,7 @@ //! When compiling the `lightwalletd` gRPC tests, also builds a gRPC client //! Rust API for `lightwalletd`. +use std::process::Command; use vergen::EmitBuilder; /// Returns a new `vergen` builder, configured for everything except for `git` env vars. @@ -18,6 +19,18 @@ fn base_vergen_builder() -> EmitBuilder { vergen } +/// Run a git command and return the output, or a fallback value if it fails +fn run_git_command(args: &[&str], fallback: &str) -> String { + Command::new("git") + .args(args) + .output() + .ok() + .and_then(|o| String::from_utf8(o.stdout).ok()) + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .unwrap_or_else(|| fallback.to_owned()) +} + /// Process entry point for `zebrad`'s build script #[allow(clippy::print_stderr)] fn main() { @@ -39,6 +52,13 @@ fn main() { } } + // Add custom git tag and commit information + let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); + let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); + + println!("cargo:rustc-env=GIT_TAG={}", git_tag); + println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); + #[cfg(feature = "lightwalletd-grpc-tests")] tonic_build::configure() .build_client(true) diff --git a/zebrad/src/application.rs b/zebrad/src/application.rs index b26734f943a..5794e7dc556 100644 --- a/zebrad/src/application.rs +++ b/zebrad/src/application.rs @@ -295,6 +295,8 @@ impl Application for ZebradApp { let git_metadata: &[(_, Option<_>)] = &[ ("branch", option_env!("VERGEN_GIT_BRANCH")), ("git commit", Self::git_commit()), + ("git tag", option_env!("GIT_TAG")), + ("git commit full", option_env!("GIT_COMMIT_FULL")), ( "commit timestamp", option_env!("VERGEN_GIT_COMMIT_TIMESTAMP"), From 8958cfc5ee320dc191d11f97aeada2ed25259a18 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 21 Jul 2025 13:33:59 +0200 Subject: [PATCH 15/49] Move code to the end of the func --- zebrad/build.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 1e5df1a7626..4d1c9a9fc94 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -52,13 +52,6 @@ fn main() { } } - // Add custom git tag and commit information - let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); - let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); - - println!("cargo:rustc-env=GIT_TAG={}", git_tag); - println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); - #[cfg(feature = "lightwalletd-grpc-tests")] tonic_build::configure() .build_client(true) @@ -72,4 +65,11 @@ fn main() { &["tests/common/lightwalletd/proto"], ) .expect("Failed to generate lightwalletd gRPC files"); + + // Add custom git tag and commit information + let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); + let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); + + println!("cargo:rustc-env=GIT_TAG={}", git_tag); + println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); } From 3ef63c89cdafd2284323c75599a9ef446e9f274a Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 21 Jul 2025 13:44:13 +0200 Subject: [PATCH 16/49] Explain --- zebrad/build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 4d1c9a9fc94..59b55d0bb9b 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -67,8 +67,8 @@ fn main() { .expect("Failed to generate lightwalletd gRPC files"); // Add custom git tag and commit information - let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); - let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); + let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); // Will be set to 'none' if .git is missing or git fails. + let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); // Will be set to 'none' if .git is missing or git fails. println!("cargo:rustc-env=GIT_TAG={}", git_tag); println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); From 72fa2e4104d54e3df35ce6cc9b83d8a776375ce2 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 21 Jul 2025 15:13:15 +0200 Subject: [PATCH 17/49] Fix cargo fmt --- zebrad/build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 59b55d0bb9b..ea421f05635 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -67,8 +67,8 @@ fn main() { .expect("Failed to generate lightwalletd gRPC files"); // Add custom git tag and commit information - let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); // Will be set to 'none' if .git is missing or git fails. - let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); // Will be set to 'none' if .git is missing or git fails. + let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); // Will be set to 'none' if .git is missing or git fails. + let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); // Will be set to 'none' if .git is missing or git fails. println!("cargo:rustc-env=GIT_TAG={}", git_tag); println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); From 2db59c60f53fbdf09a573779d2b578151989db1c Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Tue, 22 Jul 2025 14:59:10 +0200 Subject: [PATCH 18/49] Add dockerfile and regtest-config files --- testnet-single-node-deploy/dockerfile | 20 +++++++++------- .../regtest-config.toml | 24 +++++++++++++++++++ 2 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 testnet-single-node-deploy/regtest-config.toml diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 316d251f952..d0f78d4126c 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -1,17 +1,21 @@ -# Use Rust 1.81.0 as the base image FROM rust:1.81.0 -# Install required dependencies -RUN apt-get update && apt-get install -y git build-essential clang +# Set up Rust and cargo +RUN apt-get update && apt-get install git build-essential clang -y -# Copy the entire project, except whats defined in .dockerignore -COPY . . +# Set the working directory to the repo root +WORKDIR /app -# Build the 'zebrad' binary with the 'getblocktemplate-rpcs' feature enabled +# Copy the entire repository content (from parent directory) +COPY .. . + +# Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" -# Expose the default Zebra node RPC port EXPOSE 18232 -# Set the entrypoint +# Copy the config file from the testnet-single-node-deploy folder +COPY regtest-config.toml regtest-config.toml + +# Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] diff --git a/testnet-single-node-deploy/regtest-config.toml b/testnet-single-node-deploy/regtest-config.toml new file mode 100644 index 00000000000..5e2322674d9 --- /dev/null +++ b/testnet-single-node-deploy/regtest-config.toml @@ -0,0 +1,24 @@ +[mining] +miner_address = 'tmLTZegcJN5zaufWQBARHkvqC62mTumm3jR' + +[network] +network = "Regtest" + +# This section may be omitted when testing only Canopy +[network.testnet_parameters.activation_heights] +# Configured activation heights must be greater than or equal to 1, +# block height 0 is reserved for the Genesis network upgrade in Zebra +NU5 = 1 +NU6 = 1 +NU7 = 1 + +# This section may be omitted if a persistent Regtest chain state is desired +[state] +ephemeral = true + +# This section may be omitted if it's not necessary to send transactions to Zebra's mempool +[rpc] +listen_addr = "0.0.0.0:18232" + +# disable cookie auth +enable_cookie_auth = false From 95cd9469da2e13b9a5fa3cf947b581c821777e7b Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 23 Jul 2025 12:04:54 +0200 Subject: [PATCH 19/49] Test fix --- testnet-single-node-deploy/dockerfile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index d0f78d4126c..894382963f9 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -15,7 +15,8 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file from the testnet-single-node-deploy folder -COPY regtest-config.toml regtest-config.toml +#COPY regtest-config.toml regtest-config.toml # Run the zebra node -ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] +#ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] +ENTRYPOINT ["target/release/zebrad", "-c", "testnet-single-node-deploy/regtest-config.toml"] From b1ecb69d967c3527a6c1ff5c4941f8d034ce6a90 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 23 Jul 2025 12:52:41 +0200 Subject: [PATCH 20/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 894382963f9..3e1e911ace2 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -14,9 +14,8 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 -# Copy the config file from the testnet-single-node-deploy folder -#COPY regtest-config.toml regtest-config.toml +# Copy the config file to the working directory for easier access +COPY testnet-single-node-deploy/regtest-config.toml ./regtest-config.toml # Run the zebra node -#ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] -ENTRYPOINT ["target/release/zebrad", "-c", "testnet-single-node-deploy/regtest-config.toml"] +ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From aef9d6d60def09ef8ac6cdf33f194f2a6e17e3e1 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 23 Jul 2025 12:59:21 +0200 Subject: [PATCH 21/49] Update dockerfile2 --- testnet-single-node-deploy/dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 3e1e911ace2..bf6ee7fbe8f 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -15,7 +15,7 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file to the working directory for easier access -COPY testnet-single-node-deploy/regtest-config.toml ./regtest-config.toml +COPY regtest-config.toml ./regtest-config.toml # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From b1a692a19bd68a9bfd9c5e169d55db18690dc3f8 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 23 Jul 2025 13:01:28 +0200 Subject: [PATCH 22/49] Update dockerfile3 --- testnet-single-node-deploy/dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index bf6ee7fbe8f..3e1e911ace2 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -15,7 +15,7 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file to the working directory for easier access -COPY regtest-config.toml ./regtest-config.toml +COPY testnet-single-node-deploy/regtest-config.toml ./regtest-config.toml # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From 9d356b8ee7900d42ad10748ba7f14e7d5845b8cf Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 23 Jul 2025 15:18:51 +0200 Subject: [PATCH 23/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 3e1e911ace2..d0f78d4126c 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -14,8 +14,8 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 -# Copy the config file to the working directory for easier access -COPY testnet-single-node-deploy/regtest-config.toml ./regtest-config.toml +# Copy the config file from the testnet-single-node-deploy folder +COPY regtest-config.toml regtest-config.toml # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From b61489b22642f445304bb547ebe682ef5a11f11f Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Fri, 25 Jul 2025 15:48:37 +0200 Subject: [PATCH 24/49] Fix --- testnet-single-node-deploy/dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index d0f78d4126c..b33115dd354 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -7,7 +7,7 @@ RUN apt-get update && apt-get install git build-essential clang -y WORKDIR /app # Copy the entire repository content (from parent directory) -COPY .. . +COPY . . # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" @@ -15,7 +15,7 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file from the testnet-single-node-deploy folder -COPY regtest-config.toml regtest-config.toml +COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From b42da4995daf9e36365d43d3d35d379b67414648 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Fri, 25 Jul 2025 16:04:59 +0200 Subject: [PATCH 25/49] Revert to built --- testnet-single-node-deploy/dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index b33115dd354..d0f78d4126c 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -7,7 +7,7 @@ RUN apt-get update && apt-get install git build-essential clang -y WORKDIR /app # Copy the entire repository content (from parent directory) -COPY . . +COPY .. . # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" @@ -15,7 +15,7 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file from the testnet-single-node-deploy folder -COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml +COPY regtest-config.toml regtest-config.toml # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] From afdc33dc46a51c76d656f9dfdf9be338f67e83d4 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 11:04:54 +0200 Subject: [PATCH 26/49] Create regtest-config.toml --- .../regtest-config.toml | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 testnet-single-node-deploy/regtest-config.toml diff --git a/testnet-single-node-deploy/regtest-config.toml b/testnet-single-node-deploy/regtest-config.toml new file mode 100644 index 00000000000..5e2322674d9 --- /dev/null +++ b/testnet-single-node-deploy/regtest-config.toml @@ -0,0 +1,24 @@ +[mining] +miner_address = 'tmLTZegcJN5zaufWQBARHkvqC62mTumm3jR' + +[network] +network = "Regtest" + +# This section may be omitted when testing only Canopy +[network.testnet_parameters.activation_heights] +# Configured activation heights must be greater than or equal to 1, +# block height 0 is reserved for the Genesis network upgrade in Zebra +NU5 = 1 +NU6 = 1 +NU7 = 1 + +# This section may be omitted if a persistent Regtest chain state is desired +[state] +ephemeral = true + +# This section may be omitted if it's not necessary to send transactions to Zebra's mempool +[rpc] +listen_addr = "0.0.0.0:18232" + +# disable cookie auth +enable_cookie_auth = false From 487d5f11bb68bcac158cc10b1c8f6f0ae3e02cfc Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 22:28:39 +0200 Subject: [PATCH 27/49] Adjust --- testnet-single-node-deploy/dockerfile | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index d0f78d4126c..925d0c6e408 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -6,8 +6,8 @@ RUN apt-get update && apt-get install git build-essential clang -y # Set the working directory to the repo root WORKDIR /app -# Copy the entire repository content (from parent directory) -COPY .. . +# Copy the entire repository content (from the parent zebra directory) +COPY . . # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" @@ -15,7 +15,7 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Copy the config file from the testnet-single-node-deploy folder -COPY regtest-config.toml regtest-config.toml +COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml # Run the zebra node -ENTRYPOINT ["target/release/zebrad", "-c", "regtest-config.toml"] +ENTRYPOINT ["target/release/zebrad", "-c", "testnet-single-node-deploy/regtest-config.toml"] From 0b63eddb54132ae224a31162e9c9948ad7803983 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 22:36:13 +0200 Subject: [PATCH 28/49] Adjust --- testnet-single-node-deploy/dockerfile | 3 --- 1 file changed, 3 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 925d0c6e408..7a5c2316613 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -14,8 +14,5 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 -# Copy the config file from the testnet-single-node-deploy folder -COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml - # Run the zebra node ENTRYPOINT ["target/release/zebrad", "-c", "testnet-single-node-deploy/regtest-config.toml"] From d5425317dae603eaf251622af9df01af9cad17e1 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 23:14:55 +0200 Subject: [PATCH 29/49] Adjust --- testnet-single-node-deploy/dockerfile | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 7a5c2316613..5e021d1c936 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -9,10 +9,16 @@ WORKDIR /app # Copy the entire repository content (from the parent zebra directory) COPY . . +# Copy config file to working directory for easy access +COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml + +RUN ls -la /app/testnet-single-node-deploy/ +RUN cat /app/testnet-single-node-deploy/regtest-config.toml + # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" EXPOSE 18232 # Run the zebra node -ENTRYPOINT ["target/release/zebrad", "-c", "testnet-single-node-deploy/regtest-config.toml"] +ENTRYPOINT ["target/release/zebrd", "-c", "regtest-config.toml"] From 91b9760277cdfc5a11063f9eb9617f87119b25b5 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 23:17:58 +0200 Subject: [PATCH 30/49] Adjust --- testnet-single-node-deploy/dockerfile | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 5e021d1c936..2cd1326e200 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -9,9 +9,6 @@ WORKDIR /app # Copy the entire repository content (from the parent zebra directory) COPY . . -# Copy config file to working directory for easy access -COPY testnet-single-node-deploy/regtest-config.toml regtest-config.toml - RUN ls -la /app/testnet-single-node-deploy/ RUN cat /app/testnet-single-node-deploy/regtest-config.toml @@ -21,4 +18,4 @@ RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemp EXPOSE 18232 # Run the zebra node -ENTRYPOINT ["target/release/zebrd", "-c", "regtest-config.toml"] +ENTRYPOINT ["target/release/zebrd", "-c", "/app/testnet-single-node-deploy/regtest-config.toml"] From 937d8128b03a1444a518bde7a7a9a451554a5841 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 23:20:21 +0200 Subject: [PATCH 31/49] Adjust --- testnet-single-node-deploy/dockerfile | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 2cd1326e200..d8825a9ea37 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -9,8 +9,10 @@ WORKDIR /app # Copy the entire repository content (from the parent zebra directory) COPY . . -RUN ls -la /app/testnet-single-node-deploy/ -RUN cat /app/testnet-single-node-deploy/regtest-config.toml +RUN ls -la /app/ +RUN find /app -name "*testnet*" -type d +RUN find /app -name "*regtest*" -type f +RUN pwd && ls -la # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" From 91819f84b9e0de4e228273907b5aa908a4cdb62d Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 23:26:04 +0200 Subject: [PATCH 32/49] Fix dockerignore.. --- .dockerignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.dockerignore b/.dockerignore index 9d62f3c5c13..5e8ce3ec2e9 100644 --- a/.dockerignore +++ b/.dockerignore @@ -21,3 +21,5 @@ !zebra-* !zebrad !docker/entrypoint.sh + +!testnet-single-node-deploy/ From dd2b2a6a60772def2a80e6ff9628772ca1049aa4 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sat, 26 Jul 2025 23:49:23 +0200 Subject: [PATCH 33/49] Fix typo --- testnet-single-node-deploy/dockerfile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index d8825a9ea37..0f320665cbc 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -17,7 +17,10 @@ RUN pwd && ls -la # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" +RUN ls -la target/release/ +RUN find target/release -name "*zebr*" -type f + EXPOSE 18232 # Run the zebra node -ENTRYPOINT ["target/release/zebrd", "-c", "/app/testnet-single-node-deploy/regtest-config.toml"] +ENTRYPOINT ["target/release/zebrad", "-c", "/app/testnet-single-node-deploy/regtest-config.toml"] From e09ad24d53120841886e1d367007bbbd9578fee3 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sun, 27 Jul 2025 09:44:30 +0200 Subject: [PATCH 34/49] Update .dockerignore --- .dockerignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.dockerignore b/.dockerignore index 5e8ce3ec2e9..f7107840100 100644 --- a/.dockerignore +++ b/.dockerignore @@ -21,5 +21,4 @@ !zebra-* !zebrad !docker/entrypoint.sh - !testnet-single-node-deploy/ From fdb4c48dd5e86ad11be3d26ca9d9aa79be40db28 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sun, 27 Jul 2025 13:22:07 +0200 Subject: [PATCH 35/49] Clean dockerfile --- testnet-single-node-deploy/dockerfile | 8 -------- 1 file changed, 8 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 0f320665cbc..89a29799f44 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -9,17 +9,9 @@ WORKDIR /app # Copy the entire repository content (from the parent zebra directory) COPY . . -RUN ls -la /app/ -RUN find /app -name "*testnet*" -type d -RUN find /app -name "*regtest*" -type f -RUN pwd && ls -la - # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" -RUN ls -la target/release/ -RUN find target/release -name "*zebr*" -type f - EXPOSE 18232 # Run the zebra node From 9bacc7624b4fc46cfed2c6cd0da62ecbc78c7dc6 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Sun, 27 Jul 2025 14:26:09 +0200 Subject: [PATCH 36/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 89a29799f44..b0d2822894e 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -6,7 +6,7 @@ RUN apt-get update && apt-get install git build-essential clang -y # Set the working directory to the repo root WORKDIR /app -# Copy the entire repository content (from the parent zebra directory) +# Copy files COPY . . # Build zebrad with the required features From e0343c740899e6dcb35dd603e9906d5a38c2f281 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 28 Jul 2025 11:07:58 +0200 Subject: [PATCH 37/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index b0d2822894e..65fc5ad60e2 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -6,6 +6,9 @@ RUN apt-get update && apt-get install git build-essential clang -y # Set the working directory to the repo root WORKDIR /app +# Validate the presence of the config file +RUN test -f /app/testnet-single-node-deploy/regtest-config.toml + # Copy files COPY . . From 64977380fbaa1b4965996829ce9e370b984639a8 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 28 Jul 2025 11:11:13 +0200 Subject: [PATCH 38/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 65fc5ad60e2..2632ff65542 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -6,8 +6,11 @@ RUN apt-get update && apt-get install git build-essential clang -y # Set the working directory to the repo root WORKDIR /app +RUN ls -al +RUN ls -al ./testnet-single-node-deploy + # Validate the presence of the config file -RUN test -f /app/testnet-single-node-deploy/regtest-config.toml +RUN test -f testnet-single-node-deploy/regtest-config.toml # Copy files COPY . . From 90cc5e73c8343b58b7aa1528c61aeeac988ef943 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 28 Jul 2025 11:13:19 +0200 Subject: [PATCH 39/49] Update dockerfile --- testnet-single-node-deploy/dockerfile | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 2632ff65542..51a54b34afa 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -6,15 +6,12 @@ RUN apt-get update && apt-get install git build-essential clang -y # Set the working directory to the repo root WORKDIR /app -RUN ls -al -RUN ls -al ./testnet-single-node-deploy +# Copy files +COPY . . # Validate the presence of the config file RUN test -f testnet-single-node-deploy/regtest-config.toml -# Copy files -COPY . . - # Build zebrad with the required features RUN cargo build --release --package zebrad --bin zebrad --features="getblocktemplate-rpcs" From a55cf6cf956656acb891717ea86c5e6fb32f281a Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 4 Aug 2025 10:09:09 +0200 Subject: [PATCH 40/49] Update push-ecr.yaml --- .github/workflows/push-ecr.yaml | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/.github/workflows/push-ecr.yaml b/.github/workflows/push-ecr.yaml index 6e38c2ac0dd..2054cb1b9e5 100644 --- a/.github/workflows/push-ecr.yaml +++ b/.github/workflows/push-ecr.yaml @@ -70,7 +70,11 @@ jobs: # Build docker container with multiple tags DOCKER_BUILD_ARGS=() DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST") - DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION") + + # Only add IMAGE_TAG_VERSION if it's not empty + if [ -n "$IMAGE_TAG_VERSION" ]; then + DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION") + fi # Add exact tag if it exists if [ -n "$GIT_TAG" ]; then @@ -92,25 +96,27 @@ jobs: # Push all tags with error handling for tag in "$IMAGE_TAG_LATEST" "$IMAGE_TAG_VERSION" "$GIT_TAG"; do - # Skip empty tags (e.g., if GIT_TAG is unset) - [ -z "$tag" ] && continue - - image="$ECR_REGISTRY/$ECR_REPOSITORY:$tag" - echo "Pushing $image…" - if ! docker push "$image"; then - echo "Failed to push $image" - exit 1 - fi - done + # Skip empty tags (e.g., if IMAGE_TAG_VERSION or GIT_TAG is unset) + [ -z "$tag" ] && continue + image="$ECR_REGISTRY/$ECR_REPOSITORY:$tag" + echo "Pushing $image…" + if ! docker push "$image"; then + echo "Failed to push $image" + exit 1 + fi + done # Output the image URIs echo "image_latest=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST" >> $GITHUB_OUTPUT - echo "image_version=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION" >> $GITHUB_OUTPUT + + if [ -n "$IMAGE_TAG_VERSION" ]; then + echo "image_version=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_VERSION" >> $GITHUB_OUTPUT + fi if [ -n "$GIT_TAG" ]; then echo "image_exact_tag=$ECR_REGISTRY/$ECR_REPOSITORY:$GIT_TAG" >> $GITHUB_OUTPUT fi - + # Print the public repository URL echo "" echo "=====================================" From 01ab25c6cbfd52f90cc3a19004a4b58db85b62ce Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 6 Aug 2025 14:57:55 +0200 Subject: [PATCH 41/49] Add git commit and tag from env var, and rust fallback --- .github/workflows/push-ecr.yaml | 17 +++++++++++++++-- testnet-single-node-deploy/dockerfile | 9 +++++++++ zebrad/build.rs | 7 +++++-- 3 files changed, 29 insertions(+), 4 deletions(-) diff --git a/.github/workflows/push-ecr.yaml b/.github/workflows/push-ecr.yaml index 6e38c2ac0dd..e40e19d6bc5 100644 --- a/.github/workflows/push-ecr.yaml +++ b/.github/workflows/push-ecr.yaml @@ -27,6 +27,8 @@ jobs: steps: - name: Checkout uses: actions/checkout@v4 + with: + fetch-depth: 0 - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v4 @@ -67,6 +69,14 @@ jobs: ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }} IMAGE_TAG_LATEST: latest run: | + # Get Git information for build args + GIT_COMMIT=$(git rev-parse HEAD) + GIT_TAG_BUILD=$(git describe --exact-match --tags 2>/dev/null || echo "none") + + echo "Git information for build:" + echo " Commit: $GIT_COMMIT" + echo " Tag: $GIT_TAG_BUILD" + # Build docker container with multiple tags DOCKER_BUILD_ARGS=() DOCKER_BUILD_ARGS+=("-t" "$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG_LATEST") @@ -86,9 +96,12 @@ jobs: done echo "" - # Build with all tags + # Build with all tags and Git build args echo "Building Docker image..." - docker build "${DOCKER_BUILD_ARGS[@]}" -f $DOCKERFILE_PATH . + docker build "${DOCKER_BUILD_ARGS[@]}" \ + --build-arg GIT_COMMIT="$GIT_COMMIT" \ + --build-arg GIT_TAG="$GIT_TAG_BUILD" \ + -f $DOCKERFILE_PATH . # Push all tags with error handling for tag in "$IMAGE_TAG_LATEST" "$IMAGE_TAG_VERSION" "$GIT_TAG"; do diff --git a/testnet-single-node-deploy/dockerfile b/testnet-single-node-deploy/dockerfile index 51a54b34afa..cfcd68c5bc4 100644 --- a/testnet-single-node-deploy/dockerfile +++ b/testnet-single-node-deploy/dockerfile @@ -1,5 +1,9 @@ FROM rust:1.81.0 +# Accept build arguments for Git information +ARG GIT_COMMIT +ARG GIT_TAG + # Set up Rust and cargo RUN apt-get update && apt-get install git build-essential clang -y @@ -9,6 +13,11 @@ WORKDIR /app # Copy files COPY . . +# Set Git environment variables for the build +# These will be used by the build.rs script +ENV GIT_COMMIT_FULL=$GIT_COMMIT +ENV GIT_TAG=$GIT_TAG + # Validate the presence of the config file RUN test -f testnet-single-node-deploy/regtest-config.toml diff --git a/zebrad/build.rs b/zebrad/build.rs index ea421f05635..9dd7f035490 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -67,8 +67,11 @@ fn main() { .expect("Failed to generate lightwalletd gRPC files"); // Add custom git tag and commit information - let git_tag = run_git_command(&["describe", "--exact-match", "--tags"], "none"); // Will be set to 'none' if .git is missing or git fails. - let git_commit = run_git_command(&["rev-parse", "HEAD"], "none"); // Will be set to 'none' if .git is missing or git fails. + // Use environment variables if available (from CI/CD), otherwise try git commands + let git_tag = std::env::var("GIT_TAG") + .unwrap_or_else(|_| run_git_command(&["describe", "--exact-match", "--tags"], "none")); + let git_commit = std::env::var("GIT_COMMIT_FULL") + .unwrap_or_else(|_| run_git_command(&["rev-parse", "HEAD"], "none")); println!("cargo:rustc-env=GIT_TAG={}", git_tag); println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); From a1b6504eb0b1ff764d11b18ee6fb3e8d6211d9ae Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Wed, 6 Aug 2025 15:16:32 +0200 Subject: [PATCH 42/49] Update build.rs --- zebrad/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 9dd7f035490..12ac5a42a3c 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -67,7 +67,7 @@ fn main() { .expect("Failed to generate lightwalletd gRPC files"); // Add custom git tag and commit information - // Use environment variables if available (from CI/CD), otherwise try git commands + // Use environment variables if available (from CI/CD), otherwise try git commands (Can be problematic as the docker image shouldn't have the .git folder in it) let git_tag = std::env::var("GIT_TAG") .unwrap_or_else(|_| run_git_command(&["describe", "--exact-match", "--tags"], "none")); let git_commit = std::env::var("GIT_COMMIT_FULL") From 505bfa295934918f07becf75a856c218c6125a20 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Thu, 7 Aug 2025 09:07:52 +0200 Subject: [PATCH 43/49] Change order --- zebrad/build.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 12ac5a42a3c..3324dc9ad6a 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -68,11 +68,10 @@ fn main() { // Add custom git tag and commit information // Use environment variables if available (from CI/CD), otherwise try git commands (Can be problematic as the docker image shouldn't have the .git folder in it) - let git_tag = std::env::var("GIT_TAG") - .unwrap_or_else(|_| run_git_command(&["describe", "--exact-match", "--tags"], "none")); let git_commit = std::env::var("GIT_COMMIT_FULL") .unwrap_or_else(|_| run_git_command(&["rev-parse", "HEAD"], "none")); - + let git_tag = std::env::var("GIT_TAG") + .unwrap_or_else(|_| run_git_command(&["describe", "--exact-match", "--tags"], "none")); println!("cargo:rustc-env=GIT_TAG={}", git_tag); println!("cargo:rustc-env=GIT_COMMIT_FULL={}", git_commit); } From 155eb10476f5f42411ec705f421aa4f85b503079 Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Mon, 11 Aug 2025 15:58:28 +0200 Subject: [PATCH 44/49] Re-phrase --- zebrad/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zebrad/build.rs b/zebrad/build.rs index 3324dc9ad6a..21fd4049597 100644 --- a/zebrad/build.rs +++ b/zebrad/build.rs @@ -67,7 +67,7 @@ fn main() { .expect("Failed to generate lightwalletd gRPC files"); // Add custom git tag and commit information - // Use environment variables if available (from CI/CD), otherwise try git commands (Can be problematic as the docker image shouldn't have the .git folder in it) + // Use environment variables if available (from CI/CD), otherwise try git commands (Can be problematic as the docker image shouldn't contain the .git folder) let git_commit = std::env::var("GIT_COMMIT_FULL") .unwrap_or_else(|_| run_git_command(&["rev-parse", "HEAD"], "none")); let git_tag = std::env::var("GIT_TAG") From 1880f93a83b4711e90f0f8c545c03ebd4053c1ac Mon Sep 17 00:00:00 2001 From: Arseni Kalma Date: Tue, 19 Aug 2025 09:07:43 +0200 Subject: [PATCH 45/49] Update deploy ecs on zsa-integration-demo branch --- .github/workflows/deploy-ecs.yaml | 49 ++++++++++++++++++++++++------- 1 file changed, 39 insertions(+), 10 deletions(-) diff --git a/.github/workflows/deploy-ecs.yaml b/.github/workflows/deploy-ecs.yaml index 7c735274ab0..04e454dcb05 100644 --- a/.github/workflows/deploy-ecs.yaml +++ b/.github/workflows/deploy-ecs.yaml @@ -2,7 +2,6 @@ # It allows manual triggering with the ability to choose which image tag to deploy. # Because of the "force-new-deployment" flag, the ECS service will update to a new 'latest' image, if one was pushed. name: Deploy to Amazon ECS - on: workflow_dispatch: inputs: @@ -11,34 +10,30 @@ on: required: true type: string default: 'latest' - env: AWS_REGION: ${{ vars.AWS_REGION || 'eu-central-1' }} ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY || 'dev-zebra-server' }} ECS_SERVICE: ${{ vars.ECS_SERVICE || 'dev-zebra' }} ECS_CLUSTER: ${{ vars.ECS_CLUSTER || 'dev-zebra-cluster' }} - + TASK_DEFINITION: ${{ vars.TASK_DEFINITION || 'dev-zebra-task' }} + CONTAINER_NAME: ${{ vars.CONTAINER_NAME || 'zebra-container' }} jobs: deploy-to-ecs: name: Deploy to ECS runs-on: ubuntu-latest environment: production - steps: - name: Checkout uses: actions/checkout@v4 - - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v4 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: ${{ env.AWS_REGION }} - - name: Login to Amazon ECR id: login-ecr uses: aws-actions/amazon-ecr-login@v2 - - name: Deploy to Amazon ECS id: deploy-ecs env: @@ -51,11 +46,37 @@ jobs: echo "Deploying image: $IMAGE_URI" echo "ECS Service: $ECS_SERVICE" echo "ECS Cluster: $ECS_CLUSTER" + echo "Task Definition: $TASK_DEFINITION" + echo "Container Name: $CONTAINER_NAME" - # Update the ECS service with the new image + # Download the current task definition + aws ecs describe-task-definition \ + --task-definition $TASK_DEFINITION \ + --query 'taskDefinition' > task-definition.json + + # Get the current task definition ARN from the downloaded file + TASK_DEFINITION_ARN=$(jq -r '.taskDefinitionArn' task-definition.json) + + echo "Current task definition ARN: $TASK_DEFINITION_ARN" + + # Update the image in the task definition + jq --arg IMAGE_URI "$IMAGE_URI" --arg CONTAINER_NAME "$CONTAINER_NAME" \ + '.containerDefinitions |= map(if .name == $CONTAINER_NAME then .image = $IMAGE_URI else . end) | del(.taskDefinitionArn, .revision, .status, .requiresAttributes, .placementConstraints, .compatibilities, .registeredAt, .registeredBy)' \ + task-definition.json > updated-task-definition.json + + # Register the new task definition + NEW_TASK_DEFINITION_ARN=$(aws ecs register-task-definition \ + --cli-input-json file://updated-task-definition.json \ + --query 'taskDefinition.taskDefinitionArn' \ + --output text) + + echo "New task definition ARN: $NEW_TASK_DEFINITION_ARN" + + # Update the ECS service with the new task definition aws ecs update-service \ --cluster $ECS_CLUSTER \ --service $ECS_SERVICE \ + --task-definition $NEW_TASK_DEFINITION_ARN \ --force-new-deployment # Wait for the service to be stable @@ -86,12 +107,20 @@ jobs: echo "deployed_image=$IMAGE_URI" >> $GITHUB_OUTPUT echo "ecs_service=$ECS_SERVICE" >> $GITHUB_OUTPUT echo "ecs_cluster=$ECS_CLUSTER" >> $GITHUB_OUTPUT - + echo "task_definition_arn=$NEW_TASK_DEFINITION_ARN" >> $GITHUB_OUTPUT - name: Get deployment status run: | echo "Deployment Status:" aws ecs describe-services \ --cluster $ECS_CLUSTER \ --services $ECS_SERVICE \ - --query 'services[0].{ServiceName:serviceName,Status:status,DesiredCount:desiredCount,RunningCount:runningCount,PendingCount:pendingCount}' \ + --query 'services[0].{ServiceName:serviceName,Status:status,DesiredCount:desiredCount,RunningCount:runningCount,PendingCount:pendingCount,TaskDefinition:taskDefinition}' \ + --output table + + echo "" + echo "Current running tasks:" + aws ecs list-tasks \ + --cluster $ECS_CLUSTER \ + --service-name $ECS_SERVICE \ + --query 'taskArns' \ --output table From 1e07ba0801731a99bc27399ca9cc8251e1b3bf52 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Mon, 3 Nov 2025 18:55:02 +0300 Subject: [PATCH 46/49] Add support for ZSA state management (non-refactored) to the demo (#89) * Defines and implements the issued asset state types * Adds issued assets to the finalized state * Validates issuance actions and burns before committing blocks to a non-finalized chain. * Adds `issued_assets` fields on `ChainInner` and `ContextuallyValidatedBlock` * Adds issued assets map to non-finalized chains * adds new column family to list of state column families * Updates AssetState, AssetStateChange, IssuedAssetsOrChange, & SemanticallyVerifiedBlock types, updates `IssuedAssetsChange::from_transactions()` method return type * Fixes tests by computing an `IssuedAssetsChange` for conversions to CheckpointVerifiedBlock * fixes finalization checks * Adds documentation to types and methods in `asset_state` module, fixes several bugs. * Fix compilation errors that appeared after the previous merge * Avoid using NonEmpty in orchard_zsa/issuance * Fix BurnItem serialization/deserializartioon errors (use LE instead of BE for amount, read amount after asset base) * Make a minor fix and add FIXME comment in orchard_flavor_ext.rs * Fix the sign of burn value in SupplyChange::add in orchard_zsa/asset_state, add a couple of FIXMEs * Fix the 'transactions must have only one burn item per asset base' error in the function of the crate (this may not be a fully correct fix). Add a couple of FIXME comments explaining the problem. * Use NoteValue from the orchard crate for BurnItem amount instead of u64 to prevent serialization errors and enable defining BurnItem in orchard, facilitating its reuse along with related functions * Use BurnItem::from instead of try_from * Fix a compilation error for the previous commit ('Use BurnItem::from instead of try_from') * Fix a compilation error for the previous commit ('Use BurnItem::from instead of try_from') (2) * Modify ValueCommitment::with_asset to accept value as a NoteValue instead of amount (with_asset is used to process orchard burn) - this allows avoiding the use of try_into for burn in binding_verification_key function * Adds TODOs * Adds state request/response variants for querying asset states * Adds a `getassetstate` RPC method * Adds snapshot test * Addesses some FIXMEs and replaces a couple others with TODOs. * Removes `issued_assets_change` field from `SemanticallyVerifiedBlock` * Temporarily disable specific Clippy checks for Rust 1.83.0 compatibility * Disable clippy warning about doc comment for empty line * Update Orchard ZSA consensus tests to calculate and check asset supply * Rename ZSA workflow tests (including file, constant and variable names) to Orchard ZSA * Add amount method to BurnItem and make BurnItem pub (visible for other crates) * Fix Orchard ZSA workflow tests to make it compilable with getblocktemplate-rpcs feature enabled * Fix clippy error * Add rust-toolchain.toml with Rust version 1.82.0 to avoid clippy errors came with Rust 1.83.0 * Fix revert_chain_with function in zebra-state to support V6/OrchardZSA * Minor fix in comments * Rename transaction_to_fake_v5 function to transaction_to_fake_min_v5 and panic if V6 passed into it * Minor fixes in comments * Revert "Minor fix in comments" This reverts commit 59fec59aa085559e075d2e578fc6de8437cd7671. * Revert "Rename transaction_to_fake_v5 function to transaction_to_fake_min_v5 and panic if V6 passed into it" This reverts commit 2ce58eff94cc1910304b6642b6f7bed62f28b760. * Revert " Minor fixes in comments" This reverts commit fac3abd67123b81704e7bc56384d53d1d5aa9b15. * Fix remaining merge conflicts * Fix compilation erros * Fix clippy warning * Fix compilation errors appeared after the previous merge * Fix compilation error * Fix compilation errors in zebra-state happened without tx-v6 feature flag enabled * Allow finalizing issued assets via the issue action when no notes are provided and the finalize flag is set to true * Refactor orchard_workflow_blocks_zsa.rs (zebra-test crate) to read test data from files, introduce and use OrchardWorkflowBlock there * Fix clippy errors * Copy tests from zsa-issued-assets-tests here and fix compilation errors * Temporarily comment out verify_issuance_blocks_test test (it fails now) * Rename remaining tx-v6 flags to tx_v6 --------- Co-authored-by: Arya --- Cargo.lock | 28 +- zebra-chain/Cargo.toml | 2 + zebra-chain/src/orchard_zsa.rs | 8 +- zebra-chain/src/orchard_zsa/asset_state.rs | 398 ++++++++++++++++++ zebra-chain/src/orchard_zsa/issuance.rs | 7 +- zebra-chain/src/transaction.rs | 40 ++ zebra-chain/src/transaction/tests/vectors.rs | 12 +- zebra-consensus/src/block.rs | 20 +- zebra-consensus/src/orchard_zsa/tests.rs | 247 ++++++++++- zebra-consensus/src/router/tests.rs | 51 +++ zebra-rpc/src/methods.rs | 43 +- zebra-rpc/src/methods/tests/snapshot.rs | 36 ++ .../snapshots/get_asset_state@mainnet.snap | 8 + .../snapshots/get_asset_state@testnet.snap | 8 + .../get_asset_state_not_found@mainnet.snap | 8 + .../get_asset_state_not_found@testnet.snap | 8 + zebra-rpc/src/sync.rs | 6 +- zebra-state/src/arbitrary.rs | 11 +- zebra-state/src/error.rs | 6 + zebra-state/src/lib.rs | 4 + zebra-state/src/request.rs | 89 +++- zebra-state/src/response.rs | 10 + zebra-state/src/service.rs | 24 ++ zebra-state/src/service/check.rs | 3 + zebra-state/src/service/check/issuance.rs | 72 ++++ zebra-state/src/service/check/tests.rs | 1 + .../src/service/check/tests/issuance.rs | 94 +++++ zebra-state/src/service/finalized_state.rs | 1 + .../finalized_state/disk_format/shielded.rs | 50 +++ .../tests/snapshots/column_family_names.snap | 1 + .../empty_column_families@mainnet_0.snap | 1 + .../empty_column_families@mainnet_1.snap | 1 + .../empty_column_families@mainnet_2.snap | 1 + .../empty_column_families@no_blocks.snap | 1 + .../empty_column_families@testnet_0.snap | 1 + .../empty_column_families@testnet_1.snap | 1 + .../empty_column_families@testnet_2.snap | 1 + .../service/finalized_state/zebra_db/block.rs | 2 +- .../finalized_state/zebra_db/shielded.rs | 74 +++- .../src/service/non_finalized_state.rs | 7 + .../src/service/non_finalized_state/chain.rs | 123 +++++- .../service/non_finalized_state/tests/prop.rs | 16 +- zebra-state/src/service/read.rs | 4 + zebra-state/src/service/read/find.rs | 14 + .../vectors/orchard-zsa-workflow-blocks-1.txt | 1 + .../vectors/orchard-zsa-workflow-blocks-2.txt | 1 + .../vectors/orchard-zsa-workflow-blocks-3.txt | 1 + .../vectors/orchard-zsa-workflow-blocks-4.txt | 2 + .../vectors/orchard-zsa-workflow-blocks-5.txt | 1 + .../vectors/orchard_zsa_workflow_blocks.rs | 56 ++- 50 files changed, 1512 insertions(+), 93 deletions(-) create mode 100644 zebra-chain/src/orchard_zsa/asset_state.rs create mode 100644 zebra-rpc/src/methods/tests/snapshots/get_asset_state@mainnet.snap create mode 100644 zebra-rpc/src/methods/tests/snapshots/get_asset_state@testnet.snap create mode 100644 zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@mainnet.snap create mode 100644 zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@testnet.snap create mode 100644 zebra-state/src/service/check/issuance.rs create mode 100644 zebra-state/src/service/check/tests/issuance.rs create mode 100644 zebra-test/src/vectors/orchard-zsa-workflow-blocks-1.txt create mode 100644 zebra-test/src/vectors/orchard-zsa-workflow-blocks-2.txt create mode 100644 zebra-test/src/vectors/orchard-zsa-workflow-blocks-3.txt create mode 100644 zebra-test/src/vectors/orchard-zsa-workflow-blocks-4.txt create mode 100644 zebra-test/src/vectors/orchard-zsa-workflow-blocks-5.txt diff --git a/Cargo.lock b/Cargo.lock index 6ef93e20732..d331b3cf401 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -441,7 +441,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "143f5327f23168716be068f8e1014ba2ea16a6c91e8777bc8927da7b51e1df1f" dependencies = [ "bs58", - "hmac", + "hmac 0.13.0-pre.4", "rand_core 0.6.4", "ripemd 0.2.0-pre.4", "secp256k1 0.29.1", @@ -1238,6 +1238,7 @@ dependencies = [ "block-buffer 0.10.4", "const-oid", "crypto-common 0.1.6", + "subtle", ] [[package]] @@ -1296,7 +1297,9 @@ dependencies = [ "der", "digest 0.10.7", "elliptic-curve", + "rfc6979", "signature", + "spki", ] [[package]] @@ -1364,6 +1367,7 @@ dependencies = [ "ff", "generic-array", "group", + "pkcs8", "rand_core 0.6.4", "sec1", "subtle", @@ -1926,6 +1930,15 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46" +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest 0.10.7", +] + [[package]] name = "hmac" version = "0.13.0-pre.4" @@ -2485,6 +2498,7 @@ dependencies = [ "cfg-if 1.0.0", "ecdsa", "elliptic-curve", + "once_cell", "sha2 0.10.8", "signature", ] @@ -3794,6 +3808,16 @@ dependencies = [ "winreg", ] +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac 0.12.1", + "subtle", +] + [[package]] name = "rgb" version = "0.8.47" @@ -4049,6 +4073,7 @@ dependencies = [ "base16ct", "der", "generic-array", + "pkcs8", "subtle", "zeroize", ] @@ -6147,6 +6172,7 @@ dependencies = [ "incrementalmerkletree", "itertools 0.13.0", "jubjub", + "k256", "lazy_static", "nonempty 0.7.0", "num-integer", diff --git a/zebra-chain/Cargo.toml b/zebra-chain/Cargo.toml index bc1aa13ca73..9af8124d2d1 100644 --- a/zebra-chain/Cargo.toml +++ b/zebra-chain/Cargo.toml @@ -157,6 +157,8 @@ rand_chacha = { version = "0.3.1", optional = true } zebra-test = { path = "../zebra-test/", version = "1.0.0-beta.41", optional = true } +k256 = "0.13.3" + [dev-dependencies] # Benchmarks criterion = { version = "0.5.1", features = ["html_reports"] } diff --git a/zebra-chain/src/orchard_zsa.rs b/zebra-chain/src/orchard_zsa.rs index a90c115a9b3..1f5c4bc7cc2 100644 --- a/zebra-chain/src/orchard_zsa.rs +++ b/zebra-chain/src/orchard_zsa.rs @@ -3,8 +3,14 @@ #[cfg(any(test, feature = "proptest-impl"))] mod arbitrary; +pub mod asset_state; mod burn; mod issuance; -pub(crate) use burn::{compute_burn_value_commitment, Burn, BurnItem, NoBurn}; +pub(crate) use burn::{compute_burn_value_commitment, Burn, NoBurn}; pub(crate) use issuance::IssueData; + +pub use burn::BurnItem; + +// FIXME: should asset_state mod be pub and these structs be pub as well? +pub use asset_state::{AssetBase, AssetState, AssetStateChange, IssuedAssets, IssuedAssetsChange}; diff --git a/zebra-chain/src/orchard_zsa/asset_state.rs b/zebra-chain/src/orchard_zsa/asset_state.rs new file mode 100644 index 00000000000..859d38a41f6 --- /dev/null +++ b/zebra-chain/src/orchard_zsa/asset_state.rs @@ -0,0 +1,398 @@ +//! Defines and implements the issued asset state types + +use std::{collections::HashMap, sync::Arc}; + +use orchard::issuance::{compute_asset_desc_hash, IssueAction}; +pub use orchard::note::AssetBase; + +use crate::{serialization::ZcashSerialize, transaction::Transaction}; + +use super::{BurnItem, IssueData}; + +/// The circulating supply and whether that supply has been finalized. +#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)] +pub struct AssetState { + /// Indicates whether the asset is finalized such that no more of it can be issued. + pub is_finalized: bool, + + /// The circulating supply that has been issued for an asset. + pub total_supply: u64, +} + +/// A change to apply to the issued assets map. +// TODO: Reference ZIP +#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct AssetStateChange { + /// Whether the asset should be finalized such that no more of it can be issued. + pub should_finalize: bool, + /// Whether the asset has been issued in this change. + pub includes_issuance: bool, + /// The change in supply from newly issued assets or burned assets, if any. + pub supply_change: SupplyChange, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +/// An asset supply change to apply to the issued assets map. +pub enum SupplyChange { + /// An issuance that should increase the total supply of an asset + Issuance(u64), + + /// A burn that should reduce the total supply of an asset. + Burn(u64), +} + +impl Default for SupplyChange { + fn default() -> Self { + Self::Issuance(0) + } +} + +// FIXME: can we reuse some functions from orchard crate?s +impl SupplyChange { + /// Applies `self` to a provided `total_supply` of an asset. + /// + /// Returns the updated total supply after the [`SupplyChange`] has been applied. + fn apply_to(self, total_supply: u64) -> Option { + match self { + SupplyChange::Issuance(amount) => total_supply.checked_add(amount), + SupplyChange::Burn(amount) => total_supply.checked_sub(amount), + } + } + + /// Returns the [`SupplyChange`] amount as an [`i128`] where burned amounts + /// are negative. + fn as_i128(self) -> i128 { + match self { + SupplyChange::Issuance(amount) => i128::from(amount), + SupplyChange::Burn(amount) => -i128::from(amount), + } + } + + /// Attempts to add another supply change to `self`. + /// + /// Returns true if successful or false if the result would be invalid. + fn add(&mut self, rhs: Self) -> bool { + if let Some(result) = self + .as_i128() + .checked_add(rhs.as_i128()) + .and_then(|signed| match signed { + // Burn amounts MUST not be 0 + // TODO: Reference ZIP + 0.. => signed.try_into().ok().map(Self::Issuance), + // FIXME: (-signed) - is this a correct fix? + ..0 => (-signed).try_into().ok().map(Self::Burn), + }) + { + *self = result; + true + } else { + false + } + } + + /// Returns true if this [`SupplyChange`] is an issuance. + pub fn is_issuance(&self) -> bool { + matches!(self, SupplyChange::Issuance(_)) + } +} + +impl std::ops::Neg for SupplyChange { + type Output = Self; + + fn neg(self) -> Self::Output { + match self { + Self::Issuance(amount) => Self::Burn(amount), + Self::Burn(amount) => Self::Issuance(amount), + } + } +} + +impl AssetState { + /// Updates and returns self with the provided [`AssetStateChange`] if + /// the change is valid, or returns None otherwise. + pub fn apply_change(self, change: AssetStateChange) -> Option { + self.apply_finalization(change)?.apply_supply_change(change) + } + + /// Updates the `is_finalized` field on `self` if the change is valid and + /// returns `self`, or returns None otherwise. + fn apply_finalization(mut self, change: AssetStateChange) -> Option { + if self.is_finalized && change.includes_issuance { + None + } else { + self.is_finalized |= change.should_finalize; + Some(self) + } + } + + /// Updates the `supply_change` field on `self` if the change is valid and + /// returns `self`, or returns None otherwise. + fn apply_supply_change(mut self, change: AssetStateChange) -> Option { + self.total_supply = change.supply_change.apply_to(self.total_supply)?; + Some(self) + } + + /// Reverts the provided [`AssetStateChange`]. + pub fn revert_change(&mut self, change: AssetStateChange) { + *self = self + .revert_finalization(change.should_finalize) + .revert_supply_change(change) + .expect("reverted change should be validated"); + } + + /// Reverts the changes to `is_finalized` from the provied [`AssetStateChange`]. + fn revert_finalization(mut self, should_finalize: bool) -> Self { + self.is_finalized &= !should_finalize; + self + } + + /// Reverts the changes to `supply_change` from the provied [`AssetStateChange`]. + fn revert_supply_change(mut self, change: AssetStateChange) -> Option { + self.total_supply = (-change.supply_change).apply_to(self.total_supply)?; + Some(self) + } +} + +impl From> for IssuedAssets { + fn from(issued_assets: HashMap) -> Self { + Self(issued_assets) + } +} + +impl AssetStateChange { + /// Creates a new [`AssetStateChange`] from an asset base, supply change, and + /// `should_finalize` flag. + fn new( + asset_base: AssetBase, + supply_change: SupplyChange, + should_finalize: bool, + ) -> (AssetBase, Self) { + ( + asset_base, + Self { + should_finalize, + includes_issuance: supply_change.is_issuance(), + supply_change, + }, + ) + } + + /// Accepts a transaction and returns an iterator of asset bases and issued asset state changes + /// that should be applied to those asset bases when committing the transaction to the chain state. + fn from_transaction(tx: &Arc) -> impl Iterator + '_ { + Self::from_burns(tx.orchard_burns()).chain( + tx.orchard_issue_data() + .iter() + .flat_map(Self::from_issue_data), + ) + } + + /// Accepts an [`IssueData`] and returns an iterator of asset bases and issued asset state changes + /// that should be applied to those asset bases when committing the provided issue actions to the chain state. + fn from_issue_data(issue_data: &IssueData) -> impl Iterator + '_ { + let ik = issue_data.inner().ik(); + issue_data.actions().flat_map(|action| { + let issue_asset = AssetBase::derive(ik, action.asset_desc_hash()); + Self::from_issue_action(issue_asset, action) + }) + } + + /// Accepts an [`IssueAction`] and returns an iterator of asset bases and issued asset state changes + /// that should be applied to those asset bases when committing the provided issue action to the chain state. + fn from_issue_action( + issue_asset: AssetBase, + action: &IssueAction, + ) -> impl Iterator + '_ { + (action.is_finalized() && action.notes().is_empty()) + .then(|| Self::new(issue_asset, SupplyChange::Issuance(0), true)) + .into_iter() + .chain(action.notes().iter().map(|note| { + Self::new( + note.asset(), + SupplyChange::Issuance(note.value().inner()), + action.is_finalized(), + ) + })) + } + + /// Accepts an iterator of [`BurnItem`]s and returns an iterator of asset bases and issued asset state changes + /// that should be applied to those asset bases when committing the provided asset burns to the chain state. + fn from_burns<'a>( + burns: impl Iterator + 'a, + ) -> impl Iterator + 'a { + burns.map(Self::from_burn) + } + + /// Accepts an [`BurnItem`] and returns an iterator of asset bases and issued asset state changes + /// that should be applied to those asset bases when committing the provided burn to the chain state. + fn from_burn(burn: &BurnItem) -> (AssetBase, Self) { + Self::new(burn.asset(), SupplyChange::Burn(burn.raw_amount()), false) + } + + /// Updates and returns self with the provided [`AssetStateChange`] if + /// the change is valid, or returns None otherwise. + pub fn apply_change(&mut self, change: AssetStateChange) -> bool { + if self.should_finalize && change.includes_issuance { + return false; + } + self.should_finalize |= change.should_finalize; + self.includes_issuance |= change.includes_issuance; + self.supply_change.add(change.supply_change) + } +} + +/// An map of issued asset states by asset base. +// TODO: Reference ZIP +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct IssuedAssets(HashMap); + +impl IssuedAssets { + /// Creates a new [`IssuedAssets`]. + pub fn new() -> Self { + Self(HashMap::new()) + } + + /// Returns an iterator of the inner HashMap. + pub fn iter(&self) -> impl Iterator { + self.0.iter() + } + + /// Extends inner [`HashMap`] with updated asset states from the provided iterator + fn extend<'a>(&mut self, issued_assets: impl Iterator + 'a) { + self.0.extend(issued_assets); + } +} + +impl IntoIterator for IssuedAssets { + type Item = (AssetBase, AssetState); + + type IntoIter = std::collections::hash_map::IntoIter; + + fn into_iter(self) -> Self::IntoIter { + self.0.into_iter() + } +} + +/// A map of changes to apply to the issued assets map. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct IssuedAssetsChange(HashMap); + +impl IssuedAssetsChange { + /// Creates a new [`IssuedAssetsChange`]. + fn new() -> Self { + Self(HashMap::new()) + } + + /// Applies changes in the provided iterator to an [`IssuedAssetsChange`]. + fn update<'a>( + &mut self, + changes: impl Iterator + 'a, + ) -> bool { + for (asset_base, change) in changes { + if !self.0.entry(asset_base).or_default().apply_change(change) { + return false; + } + } + + true + } + + /// Accepts a [`Arc`]. + /// + /// Returns an [`IssuedAssetsChange`] representing all of the changes to the issued assets + /// map that should be applied for the provided transaction, or `None` if the change would be invalid. + pub fn from_transaction(transaction: &Arc) -> Option { + let mut issued_assets_change = Self::new(); + + if !issued_assets_change.update(AssetStateChange::from_transaction(transaction)) { + return None; + } + + Some(issued_assets_change) + } + + /// Accepts a slice of [`Arc`]s. + /// + /// Returns an [`IssuedAssetsChange`] representing all of the changes to the issued assets + /// map that should be applied for the provided transactions. + pub fn from_transactions(transactions: &[Arc]) -> Option> { + transactions.iter().map(Self::from_transaction).collect() + } + + /// Consumes self and accepts a closure for looking up previous asset states. + /// + /// Applies changes in self to the previous asset state. + /// + /// Returns an [`IssuedAssets`] with the updated asset states. + pub fn apply_with(self, f: impl Fn(AssetBase) -> AssetState) -> IssuedAssets { + let mut issued_assets = IssuedAssets::new(); + + issued_assets.extend(self.0.into_iter().map(|(asset_base, change)| { + ( + asset_base, + f(asset_base) + .apply_change(change) + .expect("must be valid change"), + ) + })); + + issued_assets + } + + /// Iterates over the inner [`HashMap`] of asset bases and state changes. + pub fn iter(&self) -> impl Iterator + '_ { + self.0.iter().map(|(&base, &state)| (base, state)) + } +} + +impl std::ops::Add for IssuedAssetsChange { + type Output = Self; + + fn add(mut self, mut rhs: Self) -> Self { + if self.0.len() > rhs.0.len() { + self.update(rhs.0.into_iter()); + self + } else { + rhs.update(self.0.into_iter()); + rhs + } + } +} + +impl From> for IssuedAssetsChange { + fn from(change: Arc<[IssuedAssetsChange]>) -> Self { + change + .iter() + .cloned() + .reduce(|a, b| a + b) + .unwrap_or_default() + } +} + +/// Used in snapshot test for `getassetstate` RPC method. +// TODO: Replace with `AssetBase::random()` or a known value. +pub trait RandomAssetBase { + /// Generates a ZSA random asset. + /// + /// This is only used in tests. + fn random_serialized() -> String; +} + +impl RandomAssetBase for AssetBase { + fn random_serialized() -> String { + let isk = orchard::keys::IssuanceAuthorizingKey::from_bytes( + k256::NonZeroScalar::random(&mut rand_core::OsRng) + .to_bytes() + .into(), + ) + .unwrap(); + let ik = orchard::keys::IssuanceValidatingKey::from(&isk); + let asset_desc = b"zsa_asset"; + let asset_desc_hash = + compute_asset_desc_hash(&(asset_desc[0], asset_desc[1..].to_vec()).into()); + AssetBase::derive(&ik, &asset_desc_hash) + .zcash_serialize_to_vec() + .map(hex::encode) + .expect("random asset base should serialize") + } +} diff --git a/zebra-chain/src/orchard_zsa/issuance.rs b/zebra-chain/src/orchard_zsa/issuance.rs index 62305fc0892..d7add731836 100644 --- a/zebra-chain/src/orchard_zsa/issuance.rs +++ b/zebra-chain/src/orchard_zsa/issuance.rs @@ -8,7 +8,7 @@ use group::ff::PrimeField; use halo2::pasta::pallas; use orchard::{ - issuance::{IssueBundle, Signed}, + issuance::{IssueAction, IssueBundle, Signed}, note::ExtractedNoteCommitment, }; @@ -47,6 +47,11 @@ impl IssueData { }) }) } + + /// Returns issuance actions + pub fn actions(&self) -> impl Iterator { + self.0.actions().iter() + } } impl ZcashSerialize for Option { diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs index 92448445a02..f4467328a21 100644 --- a/zebra-chain/src/transaction.rs +++ b/zebra-chain/src/transaction.rs @@ -1104,6 +1104,46 @@ impl Transaction { } } + /// Access the Orchard issue data in this transaction, if any, + /// regardless of version. + #[cfg(feature = "tx_v6")] + pub fn orchard_issue_data(&self) -> &Option { + match self { + Transaction::V1 { .. } + | Transaction::V2 { .. } + | Transaction::V3 { .. } + | Transaction::V4 { .. } + | Transaction::V5 { .. } => &None, + + Transaction::V6 { + orchard_zsa_issue_data, + .. + } => orchard_zsa_issue_data, + } + } + + /// Access the Orchard asset burns in this transaction, if there are any, + /// regardless of version. + #[cfg(feature = "tx_v6")] + pub fn orchard_burns(&self) -> Box + '_> { + match self { + Transaction::V1 { .. } + | Transaction::V2 { .. } + | Transaction::V3 { .. } + | Transaction::V4 { .. } + | Transaction::V5 { .. } => Box::new(std::iter::empty()), + + Transaction::V6 { + orchard_shielded_data, + .. + } => Box::new( + orchard_shielded_data + .iter() + .flat_map(|data| data.burn.as_ref().iter()), + ), + } + } + /// Access the [`orchard::Flags`] in this transaction, if there is any, /// regardless of version. pub fn orchard_flags(&self) -> Option { diff --git a/zebra-chain/src/transaction/tests/vectors.rs b/zebra-chain/src/transaction/tests/vectors.rs index 636813236c6..406ec0eccda 100644 --- a/zebra-chain/src/transaction/tests/vectors.rs +++ b/zebra-chain/src/transaction/tests/vectors.rs @@ -491,8 +491,9 @@ fn v6_round_trip() { let _init_guard = zebra_test::init(); - for block_bytes in ORCHARD_ZSA_WORKFLOW_BLOCKS.iter() { - let block = block_bytes + for workflow_block in ORCHARD_ZSA_WORKFLOW_BLOCKS.iter() { + let block = workflow_block + .bytes .zcash_deserialize_into::() .expect("block is structurally valid"); @@ -502,7 +503,7 @@ fn v6_round_trip() { .expect("vec serialization is infallible"); assert_eq!( - block_bytes, &block_bytes2, + workflow_block.bytes, block_bytes2, "data must be equal if structs are equal" ); @@ -638,8 +639,9 @@ fn v6_librustzcash_tx_conversion() { let _init_guard = zebra_test::init(); - for block_bytes in ORCHARD_ZSA_WORKFLOW_BLOCKS.iter() { - let block = block_bytes + for workflow_block in ORCHARD_ZSA_WORKFLOW_BLOCKS.iter() { + let block = workflow_block + .bytes .zcash_deserialize_into::() .expect("block is structurally valid"); diff --git a/zebra-consensus/src/block.rs b/zebra-consensus/src/block.rs index 611aea2ceba..207a202f6ea 100644 --- a/zebra-consensus/src/block.rs +++ b/zebra-consensus/src/block.rs @@ -256,20 +256,22 @@ where use futures::StreamExt; while let Some(result) = async_checks.next().await { tracing::trace!(?result, remaining = async_checks.len()); - let response = result + let crate::transaction::Response::Block { + tx_id: _, + miner_fee, + legacy_sigop_count: tx_legacy_sigop_count, + } = result .map_err(Into::into) - .map_err(VerifyBlockError::Transaction)?; - - assert!( - matches!(response, tx::Response::Block { .. }), - "unexpected response from transaction verifier: {response:?}" - ); + .map_err(VerifyBlockError::Transaction)? + else { + panic!("unexpected response from transaction verifier"); + }; - legacy_sigop_count += response.legacy_sigop_count(); + legacy_sigop_count += tx_legacy_sigop_count; // Coinbase transactions consume the miner fee, // so they don't add any value to the block's total miner fee. - if let Some(miner_fee) = response.miner_fee() { + if let Some(miner_fee) = miner_fee { block_miner_fees += miner_fee; } } diff --git a/zebra-consensus/src/orchard_zsa/tests.rs b/zebra-consensus/src/orchard_zsa/tests.rs index 237e73b2983..8f6216d9521 100644 --- a/zebra-consensus/src/orchard_zsa/tests.rs +++ b/zebra-consensus/src/orchard_zsa/tests.rs @@ -1,3 +1,7 @@ +// FIXME: Consider moving thesr tests to `zebra-consensus/src/router/tests.rs`, or creating a +// `zebra-consensus/src/router/tests` directory and placing this module with a name +// 'orchard_zsa` there. + //! Simulates a full Zebra node’s block‐processing pipeline on a predefined Orchard/ZSA workflow. //! //! This integration test reads a sequence of serialized regtest blocks (including Orchard burns @@ -12,50 +16,255 @@ //! In short, it demonstrates end-to-end handling of Orchard asset burns and ZSA issuance through //! consensus (with state verification to follow in the next PR). -use std::sync::Arc; +use std::{ + collections::{hash_map, HashMap}, + sync::Arc, +}; use color_eyre::eyre::Report; +use tower::ServiceExt; + +use orchard::{ + asset_record::AssetRecord, issuance::IssueAction, keys::IssuanceValidatingKey, note::AssetBase, + value::NoteValue, +}; use zebra_chain::{ block::{genesis::regtest_genesis_block, Block, Hash}, + orchard_zsa::{AssetState, BurnItem}, parameters::Network, serialization::ZcashDeserialize, }; +use zebra_state::{ReadRequest, ReadResponse, ReadStateService}; + use zebra_test::{ transcript::{ExpectedTranscriptError, Transcript}, - vectors::ORCHARD_ZSA_WORKFLOW_BLOCKS, + vectors::{OrchardWorkflowBlock, ORCHARD_ZSA_WORKFLOW_BLOCKS}, }; use crate::{block::Request, Config}; -fn create_transcript_data() -> impl Iterator)> -{ - let workflow_blocks = ORCHARD_ZSA_WORKFLOW_BLOCKS.iter().map(|block_bytes| { - Arc::new(Block::zcash_deserialize(&block_bytes[..]).expect("block should deserialize")) - }); +type AssetRecords = HashMap; + +type TranscriptItem = (Request, Result); + +#[derive(Debug)] +enum AssetRecordsError { + BurnAssetMissing, + EmptyActionNotFinalized, + AmountOverflow, + MissingRefNote, + ModifyFinalized, +} + +/// Processes orchard burns, decreasing asset supply. +fn process_burns<'a, I: Iterator>( + asset_records: &mut AssetRecords, + burns: I, +) -> Result<(), AssetRecordsError> { + for burn in burns { + // FIXME: check for burn specific errors? + let asset_record = asset_records + .get_mut(&burn.asset()) + .ok_or(AssetRecordsError::BurnAssetMissing)?; + + asset_record.amount = NoteValue::from_raw( + asset_record + .amount + .inner() + .checked_sub(burn.amount().inner()) + .ok_or(AssetRecordsError::AmountOverflow)?, + ); + } + + Ok(()) +} + +/// Processes orchard issue actions, increasing asset supply. +fn process_issue_actions<'a, I: Iterator>( + asset_records: &mut AssetRecords, + ik: &IssuanceValidatingKey, + actions: I, +) -> Result<(), AssetRecordsError> { + for action in actions { + let action_asset = AssetBase::derive(ik, action.asset_desc_hash()); + let reference_note = action.get_reference_note(); + let is_finalized = action.is_finalized(); + + let mut note_amounts = action.notes().iter().map(|note| { + if note.asset() == action_asset { + Ok(note.value()) + } else { + Err(AssetRecordsError::BurnAssetMissing) + } + }); + + let first_note_amount = match note_amounts.next() { + Some(note_amount) => note_amount, + None => { + if is_finalized { + Ok(NoteValue::from_raw(0)) + } else { + Err(AssetRecordsError::EmptyActionNotFinalized) + } + } + }; + + for amount_result in std::iter::once(first_note_amount).chain(note_amounts) { + let amount = amount_result?; + + // FIXME: check for issuance specific errors? + match asset_records.entry(action_asset) { + hash_map::Entry::Occupied(mut entry) => { + let asset_record = entry.get_mut(); + asset_record.amount = + (asset_record.amount + amount).ok_or(AssetRecordsError::AmountOverflow)?; + if asset_record.is_finalized { + return Err(AssetRecordsError::ModifyFinalized); + } + asset_record.is_finalized = is_finalized; + } + + hash_map::Entry::Vacant(entry) => { + entry.insert(AssetRecord { + amount, + is_finalized, + reference_note: *reference_note.ok_or(AssetRecordsError::MissingRefNote)?, + }); + } + } + } + } - std::iter::once(regtest_genesis_block()) + Ok(()) +} + +/// Builds assets records for the given blocks. +fn build_asset_records<'a, I: IntoIterator>( + blocks: I, +) -> Result { + blocks + .into_iter() + .filter_map(|(request, result)| match (request, result) { + (Request::Commit(block), Ok(_)) => Some(&block.transactions), + _ => None, + }) + .flatten() + .try_fold(HashMap::new(), |mut asset_records, tx| { + process_burns(&mut asset_records, tx.orchard_burns())?; + + if let Some(issue_data) = tx.orchard_issue_data() { + process_issue_actions( + &mut asset_records, + issue_data.inner().ik(), + issue_data.actions(), + )?; + } + + Ok(asset_records) + }) +} + +/// Creates transcript data from predefined workflow blocks. +fn create_transcript_data<'a, I: IntoIterator>( + serialized_blocks: I, +) -> impl Iterator + use<'a, I> { + let workflow_blocks = + serialized_blocks + .into_iter() + .map(|OrchardWorkflowBlock { bytes, is_valid }| { + ( + Arc::new( + Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"), + ), + *is_valid, + ) + }); + + std::iter::once((regtest_genesis_block(), true)) .chain(workflow_blocks) - .map(|block| (Request::Commit(block.clone()), Ok(block.hash()))) + .map(|(block, is_valid)| { + ( + Request::Commit(block.clone()), + if is_valid { + Ok(block.hash()) + } else { + Err(ExpectedTranscriptError::Any) + }, + ) + }) +} + +/// Queries the state service for the asset state of the given asset. +async fn request_asset_state( + read_state_service: &ReadStateService, + asset_base: AssetBase, +) -> Option { + let request = ReadRequest::AssetState { + asset_base, + include_non_finalized: true, + }; + + match read_state_service.clone().oneshot(request).await { + Ok(ReadResponse::AssetState(asset_state)) => asset_state, + _ => unreachable!("The state service returned an unexpected response."), + } } #[tokio::test(flavor = "multi_thread")] -async fn check_zsa_workflow() -> Result<(), Report> { +async fn check_orchard_zsa_workflow() -> Result<(), Report> { let _init_guard = zebra_test::init(); let network = Network::new_regtest(Some(1), Some(1), Some(1)); - let state_service = zebra_state::init_test(&network); + let (state_service, read_state_service, _, _) = zebra_state::init_test_services(&network); + + let (block_verifier_router, _tx_verifier, _groth16_download_handle, _max_checkpoint_height) = + crate::router::init(Config::default(), &network, state_service.clone()).await; + + let transcript_data = + create_transcript_data(ORCHARD_ZSA_WORKFLOW_BLOCKS.iter()).collect::>(); + + let asset_records = + build_asset_records(&transcript_data).expect("should calculate asset_records"); - let ( - block_verifier_router, - _transaction_verifier, - _groth16_download_handle, - _max_checkpoint_height, - ) = crate::router::init(Config::default(), &network, state_service.clone()).await; + // Before applying the blocks, ensure that none of the assets exist in the state. + for &asset_base in asset_records.keys() { + assert!( + request_asset_state(&read_state_service, asset_base) + .await + .is_none(), + "State should initially have no info about this asset." + ); + } - Transcript::from(create_transcript_data()) + // Verify all blocks in the transcript against the consensus and the state. + Transcript::from(transcript_data) .check(block_verifier_router.clone()) - .await + .await?; + + // After processing the transcript blocks, verify that the state matches the expected supply info. + for (&asset_base, asset_record) in &asset_records { + let asset_state = request_asset_state(&read_state_service, asset_base) + .await + .expect("State should contain this asset now."); + + assert_eq!( + asset_state.is_finalized, asset_record.is_finalized, + "Finalized state does not match for asset {:?}.", + asset_base + ); + + assert_eq!( + asset_state.total_supply, + // FIXME: Fix it after chaning ValueSum to NoteValue in AssetSupply in orchard + u64::try_from(i128::from(asset_record.amount)) + .expect("asset supply amount should be within u64 range"), + "Total supply mismatch for asset {:?}.", + asset_base + ); + } + + Ok(()) } diff --git a/zebra-consensus/src/router/tests.rs b/zebra-consensus/src/router/tests.rs index 8fe304e3364..97d970ebb0f 100644 --- a/zebra-consensus/src/router/tests.rs +++ b/zebra-consensus/src/router/tests.rs @@ -270,3 +270,54 @@ async fn verify_fail_add_block_checkpoint() -> Result<(), Report> { Ok(()) } + +// FIXME: Consider removing this test. The more comprehensive `check_orchard_zsa_workflow` +// in `zebra-consensus/src/orchard_zsa/tests.rs` already verifies everything this test +// covers (and more). +// FIXME: This test is commented out because it fails when running in CI (locally, it passes) +// - This situation needs to be figured out, as it may reflect an error in the main code. +/* +#[tokio::test(flavor = "multi_thread")] +async fn verify_issuance_blocks_test() -> Result<(), Report> { + use block::genesis::regtest_genesis_block; + + use zebra_test::vectors::{OrchardWorkflowBlock, ORCHARD_ZSA_WORKFLOW_BLOCKS}; + + let _init_guard = zebra_test::init(); + + let network = Network::new_regtest(Some(1), None, Some(1)); + let (block_verifier_router, _state_service) = verifiers_from_network(network.clone()).await; + + let block_verifier_router = + TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(block_verifier_router); + + let commit_genesis = [( + Request::Commit(regtest_genesis_block()), + Ok(network.genesis_hash()), + )]; + + let commit_issuance_blocks = + ORCHARD_ZSA_WORKFLOW_BLOCKS + .iter() + .map(|OrchardWorkflowBlock { bytes, is_valid }| { + let block = Arc::new( + Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"), + ); + ( + Request::Commit(block.clone()), + if *is_valid { + Ok(block.hash()) + } else { + Err(ExpectedTranscriptError::Any) + }, + ) + }); + + Transcript::from(commit_genesis.into_iter().chain(commit_issuance_blocks)) + .check(block_verifier_router.clone()) + .await + .unwrap(); + + Ok(()) +} +*/ diff --git a/zebra-rpc/src/methods.rs b/zebra-rpc/src/methods.rs index 8becc5bb79c..f38a6e4108f 100644 --- a/zebra-rpc/src/methods.rs +++ b/zebra-rpc/src/methods.rs @@ -23,7 +23,7 @@ use zebra_chain::{ block::{self, Height, SerializedBlock}, chain_tip::{ChainTip, NetworkChainTipHeightEstimator}, parameters::{ConsensusBranchId, Network, NetworkUpgrade}, - serialization::ZcashDeserialize, + serialization::{ZcashDeserialize, ZcashDeserializeInto}, subtree::NoteCommitmentSubtreeIndex, transaction::{self, SerializedTransaction, Transaction, UnminedTx}, transparent::{self, Address}, @@ -302,6 +302,17 @@ pub trait Rpc { address_strings: AddressStrings, ) -> BoxFuture>>; + /// Returns the asset state of the provided asset base at the best chain tip or finalized chain tip. + /// + /// method: post + /// tags: blockchain + #[rpc(name = "getassetstate")] + fn get_asset_state( + &self, + asset_base: String, + include_non_finalized: Option, + ) -> BoxFuture>; + /// Stop the running zebrad process. /// /// # Notes @@ -1358,6 +1369,36 @@ where .boxed() } + fn get_asset_state( + &self, + asset_base: String, + include_non_finalized: Option, + ) -> BoxFuture> { + let state = self.state.clone(); + let include_non_finalized = include_non_finalized.unwrap_or(true); + + async move { + let asset_base = hex::decode(asset_base) + .map_server_error()? + .zcash_deserialize_into() + .map_server_error()?; + + let request = zebra_state::ReadRequest::AssetState { + asset_base, + include_non_finalized, + }; + + let zebra_state::ReadResponse::AssetState(asset_state) = + state.oneshot(request).await.map_server_error()? + else { + unreachable!("unexpected response from state service"); + }; + + asset_state.ok_or_server_error("asset base not found") + } + .boxed() + } + fn stop(&self) -> Result { #[cfg(not(target_os = "windows"))] if self.network.is_regtest() { diff --git a/zebra-rpc/src/methods/tests/snapshot.rs b/zebra-rpc/src/methods/tests/snapshot.rs index f4d7804088e..fe9e9cccd7f 100644 --- a/zebra-rpc/src/methods/tests/snapshot.rs +++ b/zebra-rpc/src/methods/tests/snapshot.rs @@ -14,6 +14,7 @@ use zebra_chain::{ block::Block, chain_tip::mock::MockChainTip, orchard, + orchard_zsa::{asset_state::RandomAssetBase, AssetBase, AssetState}, parameters::{ subsidy::POST_NU6_FUNDING_STREAMS_TESTNET, testnet::{self, ConfiguredActivationHeights, Parameters}, @@ -536,6 +537,41 @@ async fn test_mocked_rpc_response_data_for_network(network: &Network) { settings.bind(|| { insta::assert_json_snapshot!(format!("z_get_subtrees_by_index_for_orchard"), subtrees) }); + + // Test the response format from `getassetstate`. + + // Prepare the state response and make the RPC request. + let rsp = state + .expect_request_that(|req| matches!(req, ReadRequest::AssetState { .. })) + .map(|responder| responder.respond(ReadResponse::AssetState(None))); + let req = rpc.get_asset_state(AssetBase::random_serialized(), None); + + // Get the RPC error response. + let (asset_state_rsp, ..) = tokio::join!(req, rsp); + let asset_state = asset_state_rsp.expect_err("The RPC response should be an error"); + + // Check the error response. + settings + .bind(|| insta::assert_json_snapshot!(format!("get_asset_state_not_found"), asset_state)); + + // Prepare the state response and make the RPC request. + let rsp = state + .expect_request_that(|req| matches!(req, ReadRequest::AssetState { .. })) + .map(|responder| { + responder.respond(ReadResponse::AssetState(Some(AssetState { + is_finalized: true, + total_supply: 1000, + }))) + }); + let req = rpc.get_asset_state(AssetBase::random_serialized(), None); + + // Get the RPC response. + let (asset_state_rsp, ..) = tokio::join!(req, rsp); + let asset_state = + asset_state_rsp.expect("The RPC response should contain a `AssetState` struct."); + + // Check the response. + settings.bind(|| insta::assert_json_snapshot!(format!("get_asset_state"), asset_state)); } /// Snapshot `getinfo` response, using `cargo insta` and JSON serialization. diff --git a/zebra-rpc/src/methods/tests/snapshots/get_asset_state@mainnet.snap b/zebra-rpc/src/methods/tests/snapshots/get_asset_state@mainnet.snap new file mode 100644 index 00000000000..9085ab62c88 --- /dev/null +++ b/zebra-rpc/src/methods/tests/snapshots/get_asset_state@mainnet.snap @@ -0,0 +1,8 @@ +--- +source: zebra-rpc/src/methods/tests/snapshot.rs +expression: asset_state +--- +{ + "is_finalized": true, + "total_supply": 1000 +} diff --git a/zebra-rpc/src/methods/tests/snapshots/get_asset_state@testnet.snap b/zebra-rpc/src/methods/tests/snapshots/get_asset_state@testnet.snap new file mode 100644 index 00000000000..9085ab62c88 --- /dev/null +++ b/zebra-rpc/src/methods/tests/snapshots/get_asset_state@testnet.snap @@ -0,0 +1,8 @@ +--- +source: zebra-rpc/src/methods/tests/snapshot.rs +expression: asset_state +--- +{ + "is_finalized": true, + "total_supply": 1000 +} diff --git a/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@mainnet.snap b/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@mainnet.snap new file mode 100644 index 00000000000..9efcfd5868f --- /dev/null +++ b/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@mainnet.snap @@ -0,0 +1,8 @@ +--- +source: zebra-rpc/src/methods/tests/snapshot.rs +expression: asset_state +--- +{ + "code": 0, + "message": "asset base not found" +} diff --git a/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@testnet.snap b/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@testnet.snap new file mode 100644 index 00000000000..9efcfd5868f --- /dev/null +++ b/zebra-rpc/src/methods/tests/snapshots/get_asset_state_not_found@testnet.snap @@ -0,0 +1,8 @@ +--- +source: zebra-rpc/src/methods/tests/snapshot.rs +expression: asset_state +--- +{ + "code": 0, + "message": "asset base not found" +} diff --git a/zebra-rpc/src/sync.rs b/zebra-rpc/src/sync.rs index fd323ef64bb..787b2e7c5a8 100644 --- a/zebra-rpc/src/sync.rs +++ b/zebra-rpc/src/sync.rs @@ -13,8 +13,8 @@ use zebra_chain::{ }; use zebra_node_services::rpc_client::RpcRequestClient; use zebra_state::{ - spawn_init_read_only, ChainTipBlock, ChainTipChange, ChainTipSender, CheckpointVerifiedBlock, - LatestChainTip, NonFinalizedState, ReadStateService, SemanticallyVerifiedBlock, ZebraDb, + spawn_init_read_only, ChainTipBlock, ChainTipChange, ChainTipSender, LatestChainTip, + NonFinalizedState, ReadStateService, SemanticallyVerifiedBlock, ZebraDb, MAX_BLOCK_REORG_HEIGHT, }; @@ -262,7 +262,7 @@ impl TrustedChainSync { tokio::task::spawn_blocking(move || { let (height, hash) = db.tip()?; db.block(height.into()) - .map(|block| CheckpointVerifiedBlock::with_hash(block, hash)) + .map(|block| SemanticallyVerifiedBlock::with_hash(block, hash)) .map(ChainTipBlock::from) }) .wait_for_panics() diff --git a/zebra-state/src/arbitrary.rs b/zebra-state/src/arbitrary.rs index 5c0b837566a..c731334b210 100644 --- a/zebra-state/src/arbitrary.rs +++ b/zebra-state/src/arbitrary.rs @@ -96,8 +96,13 @@ impl ContextuallyVerifiedBlock { .map(|outpoint| (outpoint, zero_utxo.clone())) .collect(); - ContextuallyVerifiedBlock::with_block_and_spent_utxos(block, zero_spent_utxos) - .expect("all UTXOs are provided with zero values") + ContextuallyVerifiedBlock::with_block_and_spent_utxos( + block, + zero_spent_utxos, + #[cfg(feature = "tx_v6")] + Default::default(), + ) + .expect("all UTXOs are provided with zero values") } /// Create a [`ContextuallyVerifiedBlock`] from a [`Block`] or [`SemanticallyVerifiedBlock`], @@ -125,6 +130,8 @@ impl ContextuallyVerifiedBlock { spent_outputs: new_outputs, transaction_hashes, chain_value_pool_change: ValueBalance::zero(), + #[cfg(feature = "tx_v6")] + issued_assets: Default::default(), } } } diff --git a/zebra-state/src/error.rs b/zebra-state/src/error.rs index cf495311efb..4a20f5c29d1 100644 --- a/zebra-state/src/error.rs +++ b/zebra-state/src/error.rs @@ -264,6 +264,12 @@ pub enum ValidateContextError { tx_index_in_block: Option, transaction_hash: transaction::Hash, }, + + #[error("burn amounts must be less than issued asset supply")] + InvalidBurn, + + #[error("must not issue finalized assets")] + InvalidIssuance, } /// Trait for creating the corresponding duplicate nullifier error from a nullifier. diff --git a/zebra-state/src/lib.rs b/zebra-state/src/lib.rs index e93a3b8f905..fc6a9ba1475 100644 --- a/zebra-state/src/lib.rs +++ b/zebra-state/src/lib.rs @@ -44,6 +44,10 @@ pub use error::{ pub use request::{ CheckpointVerifiedBlock, HashOrHeight, ReadRequest, Request, SemanticallyVerifiedBlock, }; + +#[cfg(feature = "tx_v6")] +pub use request::IssuedAssetsOrChange; + pub use response::{KnownBlock, MinedTx, ReadResponse, Response}; pub use service::{ chain_tip::{ChainTipBlock, ChainTipChange, ChainTipSender, LatestChainTip, TipAction}, diff --git a/zebra-state/src/request.rs b/zebra-state/src/request.rs index 56be011d48e..a4c6ad5f78f 100644 --- a/zebra-state/src/request.rs +++ b/zebra-state/src/request.rs @@ -21,6 +21,9 @@ use zebra_chain::{ value_balance::{ValueBalance, ValueBalanceError}, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::{AssetBase, IssuedAssets, IssuedAssetsChange}; + /// Allow *only* these unused imports, so that rustdoc link resolution /// will work with inline links. #[allow(unused_imports)] @@ -223,6 +226,11 @@ pub struct ContextuallyVerifiedBlock { /// The sum of the chain value pool changes of all transactions in this block. pub(crate) chain_value_pool_change: ValueBalance, + + #[cfg(feature = "tx_v6")] + /// A partial map of `issued_assets` with entries for asset states that were updated in + /// this block. + pub(crate) issued_assets: IssuedAssets, } /// Wraps note commitment trees and the history tree together. @@ -293,12 +301,42 @@ pub struct FinalizedBlock { pub(super) treestate: Treestate, /// This block's contribution to the deferred pool. pub(super) deferred_balance: Option>, + + #[cfg(feature = "tx_v6")] + /// Updated asset states to be inserted into the finalized state, replacing the previous + /// asset states for those asset bases. + pub issued_assets: Option, +} + +#[cfg(feature = "tx_v6")] +/// Either changes to be applied to the previous `issued_assets` map for the finalized tip, or +/// updates asset states to be inserted into the finalized state, replacing the previous +/// asset states for those asset bases. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum IssuedAssetsOrChange { + /// A map of updated issued assets. + Updated(IssuedAssets), + + /// A map of changes to apply to the issued assets map. + Change(IssuedAssetsChange), +} + +#[cfg(feature = "tx_v6")] +impl From for IssuedAssetsOrChange { + fn from(updated_issued_assets: IssuedAssets) -> Self { + Self::Updated(updated_issued_assets) + } } impl FinalizedBlock { /// Constructs [`FinalizedBlock`] from [`CheckpointVerifiedBlock`] and its [`Treestate`]. pub fn from_checkpoint_verified(block: CheckpointVerifiedBlock, treestate: Treestate) -> Self { - Self::from_semantically_verified(SemanticallyVerifiedBlock::from(block), treestate) + Self::from_semantically_verified( + SemanticallyVerifiedBlock::from(block), + treestate, + #[cfg(feature = "tx_v6")] + None, + ) } /// Constructs [`FinalizedBlock`] from [`ContextuallyVerifiedBlock`] and its [`Treestate`]. @@ -306,11 +344,22 @@ impl FinalizedBlock { block: ContextuallyVerifiedBlock, treestate: Treestate, ) -> Self { - Self::from_semantically_verified(SemanticallyVerifiedBlock::from(block), treestate) + #[cfg(feature = "tx_v6")] + let issued_assets = Some(block.issued_assets.clone()); + Self::from_semantically_verified( + SemanticallyVerifiedBlock::from(block), + treestate, + #[cfg(feature = "tx_v6")] + issued_assets, + ) } /// Constructs [`FinalizedBlock`] from [`SemanticallyVerifiedBlock`] and its [`Treestate`]. - fn from_semantically_verified(block: SemanticallyVerifiedBlock, treestate: Treestate) -> Self { + fn from_semantically_verified( + block: SemanticallyVerifiedBlock, + treestate: Treestate, + #[cfg(feature = "tx_v6")] issued_assets: Option, + ) -> Self { Self { block: block.block, hash: block.hash, @@ -319,6 +368,8 @@ impl FinalizedBlock { transaction_hashes: block.transaction_hashes, treestate, deferred_balance: block.deferred_balance, + #[cfg(feature = "tx_v6")] + issued_assets, } } } @@ -384,6 +435,7 @@ impl ContextuallyVerifiedBlock { pub fn with_block_and_spent_utxos( semantically_verified: SemanticallyVerifiedBlock, mut spent_outputs: HashMap, + #[cfg(feature = "tx_v6")] issued_assets: IssuedAssets, ) -> Result { let SemanticallyVerifiedBlock { block, @@ -411,6 +463,8 @@ impl ContextuallyVerifiedBlock { &utxos_from_ordered_utxos(spent_outputs), deferred_balance, )?, + #[cfg(feature = "tx_v6")] + issued_assets, }) } } @@ -427,6 +481,7 @@ impl CheckpointVerifiedBlock { block.deferred_balance = deferred_balance; block } + /// Creates a block that's ready to be committed to the finalized state, /// using a precalculated [`block::Hash`]. /// @@ -465,7 +520,7 @@ impl SemanticallyVerifiedBlock { impl From> for CheckpointVerifiedBlock { fn from(block: Arc) -> Self { - CheckpointVerifiedBlock(SemanticallyVerifiedBlock::from(block)) + Self(SemanticallyVerifiedBlock::from(block)) } } @@ -508,19 +563,6 @@ impl From for SemanticallyVerifiedBlock { } } -impl From for SemanticallyVerifiedBlock { - fn from(finalized: FinalizedBlock) -> Self { - Self { - block: finalized.block, - hash: finalized.hash, - height: finalized.height, - new_outputs: finalized.new_outputs, - transaction_hashes: finalized.transaction_hashes, - deferred_balance: finalized.deferred_balance, - } - } -} - impl From for SemanticallyVerifiedBlock { fn from(checkpoint_verified: CheckpointVerifiedBlock) -> Self { checkpoint_verified.0 @@ -1068,6 +1110,17 @@ pub enum ReadRequest { /// Returns [`ReadResponse::TipBlockSize(usize)`](ReadResponse::TipBlockSize) /// with the current best chain tip block size in bytes. TipBlockSize, + + #[cfg(feature = "tx_v6")] + /// Returns [`ReadResponse::AssetState`] with an [`AssetState`](zebra_chain::orchard_zsa::AssetState) + /// of the provided [`AssetBase`] if it exists for the best chain tip or finalized chain tip (depending + /// on the `include_non_finalized` flag). + AssetState { + /// The [`AssetBase`] to return the asset state for. + asset_base: AssetBase, + /// Whether to include the issued asset state changes in the non-finalized state. + include_non_finalized: bool, + }, } impl ReadRequest { @@ -1105,6 +1158,8 @@ impl ReadRequest { ReadRequest::CheckBlockProposalValidity(_) => "check_block_proposal_validity", #[cfg(feature = "getblocktemplate-rpcs")] ReadRequest::TipBlockSize => "tip_block_size", + #[cfg(feature = "tx_v6")] + ReadRequest::AssetState { .. } => "asset_state", } } diff --git a/zebra-state/src/response.rs b/zebra-state/src/response.rs index 77c252b0c75..1ddef4fa86c 100644 --- a/zebra-state/src/response.rs +++ b/zebra-state/src/response.rs @@ -13,6 +13,9 @@ use zebra_chain::{ value_balance::ValueBalance, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::AssetState; + #[cfg(feature = "getblocktemplate-rpcs")] use zebra_chain::work::difficulty::CompactDifficulty; @@ -233,6 +236,10 @@ pub enum ReadResponse { #[cfg(feature = "getblocktemplate-rpcs")] /// Response to [`ReadRequest::TipBlockSize`] TipBlockSize(Option), + + #[cfg(feature = "tx_v6")] + /// Response to [`ReadRequest::AssetState`] + AssetState(Option), } /// A structure with the information needed from the state to build a `getblocktemplate` RPC response. @@ -322,6 +329,9 @@ impl TryFrom for Response { ReadResponse::ChainInfo(_) | ReadResponse::SolutionRate(_) | ReadResponse::TipBlockSize(_) => { Err("there is no corresponding Response for this ReadResponse") } + + #[cfg(feature = "tx_v6")] + ReadResponse::AssetState(_) => Err("there is no corresponding Response for this ReadResponse"), } } } diff --git a/zebra-state/src/service.rs b/zebra-state/src/service.rs index adc61f887ae..c4a593a160c 100644 --- a/zebra-state/src/service.rs +++ b/zebra-state/src/service.rs @@ -1947,6 +1947,30 @@ impl Service for ReadStateService { }) .wait_for_panics() } + + #[cfg(feature = "tx_v6")] + ReadRequest::AssetState { + asset_base, + include_non_finalized, + } => { + let state = self.clone(); + + tokio::task::spawn_blocking(move || { + span.in_scope(move || { + let best_chain = include_non_finalized + .then(|| state.latest_best_chain()) + .flatten(); + + let response = read::asset_state(best_chain, &state.db, &asset_base); + + // The work is done in the future. + timer.finish(module_path!(), line!(), "ReadRequest::AssetState"); + + Ok(ReadResponse::AssetState(response)) + }) + }) + .wait_for_panics() + } } } } diff --git a/zebra-state/src/service/check.rs b/zebra-state/src/service/check.rs index ced63bfea16..82e88005e5e 100644 --- a/zebra-state/src/service/check.rs +++ b/zebra-state/src/service/check.rs @@ -31,6 +31,9 @@ pub(crate) mod difficulty; pub(crate) mod nullifier; pub(crate) mod utxo; +#[cfg(feature = "tx_v6")] +pub(crate) mod issuance; + pub use utxo::transparent_coinbase_spend; #[cfg(test)] diff --git a/zebra-state/src/service/check/issuance.rs b/zebra-state/src/service/check/issuance.rs new file mode 100644 index 00000000000..472ffd61fd8 --- /dev/null +++ b/zebra-state/src/service/check/issuance.rs @@ -0,0 +1,72 @@ +//! Checks for issuance and burn validity. + +use std::{collections::HashMap, sync::Arc}; + +use zebra_chain::orchard_zsa::{AssetBase, AssetState, IssuedAssets, IssuedAssetsChange}; + +use crate::{service::read, SemanticallyVerifiedBlock, ValidateContextError, ZebraDb}; + +use super::Chain; + +pub fn valid_burns_and_issuance( + finalized_state: &ZebraDb, + parent_chain: &Arc, + semantically_verified: &SemanticallyVerifiedBlock, +) -> Result { + let mut issued_assets = HashMap::new(); + + // Burns need to be checked and asset state changes need to be applied per tranaction, in case + // the asset being burned was also issued in an earlier transaction in the same block. + for transaction in &semantically_verified.block.transactions { + let issued_assets_change = IssuedAssetsChange::from_transaction(transaction) + .ok_or(ValidateContextError::InvalidIssuance)?; + + // Check that no burn item attempts to burn more than the issued supply for an asset + for burn in transaction.orchard_burns() { + let asset_base = burn.asset(); + let asset_state = + asset_state(finalized_state, parent_chain, &issued_assets, &asset_base) + // The asset being burned should have been issued by a previous transaction, and + // any assets issued in previous transactions should be present in the issued assets map. + .ok_or(ValidateContextError::InvalidBurn)?; + + if asset_state.total_supply < burn.raw_amount() { + return Err(ValidateContextError::InvalidBurn); + } else { + // Any burned asset bases in the transaction will also be present in the issued assets change, + // adding a copy of initial asset state to `issued_assets` avoids duplicate disk reads. + issued_assets.insert(asset_base, asset_state); + } + } + + // TODO: Remove the `issued_assets_change` field from `SemanticallyVerifiedBlock` and get the changes + // directly from transactions here and when writing blocks to disk. + for (asset_base, change) in issued_assets_change.iter() { + let asset_state = + asset_state(finalized_state, parent_chain, &issued_assets, &asset_base) + .unwrap_or_default(); + + let updated_asset_state = asset_state + .apply_change(change) + .ok_or(ValidateContextError::InvalidIssuance)?; + + // TODO: Update `Burn` to `HashMap)` and return an error during deserialization if + // any asset base is burned twice in the same transaction + issued_assets.insert(asset_base, updated_asset_state); + } + } + + Ok(issued_assets.into()) +} + +fn asset_state( + finalized_state: &ZebraDb, + parent_chain: &Arc, + issued_assets: &HashMap, + asset_base: &AssetBase, +) -> Option { + issued_assets + .get(asset_base) + .copied() + .or_else(|| read::asset_state(Some(parent_chain), finalized_state, asset_base)) +} diff --git a/zebra-state/src/service/check/tests.rs b/zebra-state/src/service/check/tests.rs index 9608105766d..e82e9be681e 100644 --- a/zebra-state/src/service/check/tests.rs +++ b/zebra-state/src/service/check/tests.rs @@ -1,6 +1,7 @@ //! Tests for state contextual validation checks. mod anchors; +mod issuance; mod nullifier; mod utxo; mod vectors; diff --git a/zebra-state/src/service/check/tests/issuance.rs b/zebra-state/src/service/check/tests/issuance.rs new file mode 100644 index 00000000000..e4fbd3deb02 --- /dev/null +++ b/zebra-state/src/service/check/tests/issuance.rs @@ -0,0 +1,94 @@ +use std::sync::Arc; + +use zebra_chain::{ + block::{self, genesis::regtest_genesis_block, Block}, + orchard_zsa::IssuedAssets, + parameters::Network, + serialization::ZcashDeserialize, +}; + +use zebra_test::vectors::{OrchardWorkflowBlock, ORCHARD_ZSA_WORKFLOW_BLOCKS}; + +use crate::{ + check::{self, Chain}, + service::{finalized_state::FinalizedState, write::validate_and_commit_non_finalized}, + CheckpointVerifiedBlock, Config, NonFinalizedState, +}; + +fn valid_issuance_blocks() -> Vec> { + ORCHARD_ZSA_WORKFLOW_BLOCKS + .iter() + .map(|OrchardWorkflowBlock { bytes, .. }| { + Arc::new(Block::zcash_deserialize(&bytes[..]).expect("block should deserialize")) + }) + .collect() +} + +#[test] +fn check_burns_and_issuance() { + let _init_guard = zebra_test::init(); + + let network = Network::new_regtest(Some(1), None, Some(1)); + + let mut finalized_state = FinalizedState::new_with_debug( + &Config::ephemeral(), + &network, + true, + #[cfg(feature = "elasticsearch")] + false, + false, + ); + + let mut non_finalized_state = NonFinalizedState::new(&network); + + let regtest_genesis_block = regtest_genesis_block(); + let regtest_genesis_hash = regtest_genesis_block.hash(); + + finalized_state + .commit_finalized_direct(regtest_genesis_block.into(), None, "test") + .expect("unexpected invalid genesis block test vector"); + + let block = valid_issuance_blocks().first().unwrap().clone(); + let mut header = Arc::::unwrap_or_clone(block.header.clone()); + header.previous_block_hash = regtest_genesis_hash; + header.commitment_bytes = [0; 32].into(); + let block = Arc::new(Block { + header: Arc::new(header), + transactions: block.transactions.clone(), + }); + + let CheckpointVerifiedBlock(block) = CheckpointVerifiedBlock::new(block, None, None); + + let empty_chain = Chain::new( + &network, + finalized_state + .db + .finalized_tip_height() + .unwrap_or(block::Height::MIN), + finalized_state.db.sprout_tree_for_tip(), + finalized_state.db.sapling_tree_for_tip(), + finalized_state.db.orchard_tree_for_tip(), + finalized_state.db.history_tree(), + finalized_state.db.finalized_value_pool(), + ); + + let block_1_issued_assets = check::issuance::valid_burns_and_issuance( + &finalized_state.db, + &Arc::new(empty_chain), + &block, + ) + .expect("test transactions should be valid"); + + validate_and_commit_non_finalized(&finalized_state.db, &mut non_finalized_state, block) + .expect("validation should succeed"); + + let best_chain = non_finalized_state + .best_chain() + .expect("should have a non-finalized chain"); + + assert_eq!( + IssuedAssets::from(best_chain.issued_assets.clone()), + block_1_issued_assets, + "issued assets for chain should match those of block 1" + ); +} diff --git a/zebra-state/src/service/finalized_state.rs b/zebra-state/src/service/finalized_state.rs index f8c9bade5c1..94328d9e51f 100644 --- a/zebra-state/src/service/finalized_state.rs +++ b/zebra-state/src/service/finalized_state.rs @@ -91,6 +91,7 @@ pub const STATE_COLUMN_FAMILIES_IN_CODE: &[&str] = &[ "orchard_anchors", "orchard_note_commitment_tree", "orchard_note_commitment_subtree", + "orchard_issued_assets", // Chain "history_tree", "tip_chain_value_pool", diff --git a/zebra-state/src/service/finalized_state/disk_format/shielded.rs b/zebra-state/src/service/finalized_state/disk_format/shielded.rs index bcd24d5c604..8c8fc3c30a2 100644 --- a/zebra-state/src/service/finalized_state/disk_format/shielded.rs +++ b/zebra-state/src/service/finalized_state/disk_format/shielded.rs @@ -13,6 +13,9 @@ use zebra_chain::{ subtree::{NoteCommitmentSubtreeData, NoteCommitmentSubtreeIndex}, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::{AssetBase, AssetState}; + use crate::service::finalized_state::disk_format::{FromDisk, IntoDisk}; use super::block::HEIGHT_DISK_BYTES; @@ -207,3 +210,50 @@ impl FromDisk for NoteCommitmentSubtreeData { ) } } + +// TODO: Replace `.unwrap()`s with `.expect()`s + +#[cfg(feature = "tx_v6")] +impl IntoDisk for AssetState { + type Bytes = [u8; 9]; + + fn as_bytes(&self) -> Self::Bytes { + [ + vec![self.is_finalized as u8], + self.total_supply.to_be_bytes().to_vec(), + ] + .concat() + .try_into() + .unwrap() + } +} + +#[cfg(feature = "tx_v6")] +impl FromDisk for AssetState { + fn from_bytes(bytes: impl AsRef<[u8]>) -> Self { + let (&is_finalized_byte, bytes) = bytes.as_ref().split_first().unwrap(); + let (&total_supply_bytes, _bytes) = bytes.split_first_chunk().unwrap(); + + Self { + is_finalized: is_finalized_byte != 0, + total_supply: u64::from_be_bytes(total_supply_bytes), + } + } +} + +#[cfg(feature = "tx_v6")] +impl IntoDisk for AssetBase { + type Bytes = [u8; 32]; + + fn as_bytes(&self) -> Self::Bytes { + self.to_bytes() + } +} + +#[cfg(feature = "tx_v6")] +impl FromDisk for AssetBase { + fn from_bytes(bytes: impl AsRef<[u8]>) -> Self { + let (asset_base_bytes, _) = bytes.as_ref().split_first_chunk().unwrap(); + Self::from_bytes(asset_base_bytes).unwrap() + } +} diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/column_family_names.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/column_family_names.snap index d37e037cac7..33f1c76717b 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/column_family_names.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/column_family_names.snap @@ -12,6 +12,7 @@ expression: cf_names "height_by_hash", "history_tree", "orchard_anchors", + "orchard_issued_assets", "orchard_note_commitment_subtree", "orchard_note_commitment_tree", "orchard_nullifiers", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_0.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_0.snap index 3c333a9fc43..abd4ae001ec 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_0.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_0.snap @@ -5,6 +5,7 @@ expression: empty_column_families [ "balance_by_transparent_addr: no entries", "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_1.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_1.snap index cb8ac5f6aed..8b114ddce4d 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_1.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_1.snap @@ -4,6 +4,7 @@ expression: empty_column_families --- [ "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_2.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_2.snap index cb8ac5f6aed..8b114ddce4d 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_2.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@mainnet_2.snap @@ -4,6 +4,7 @@ expression: empty_column_families --- [ "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@no_blocks.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@no_blocks.snap index a2abce2083b..2d119139d26 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@no_blocks.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@no_blocks.snap @@ -11,6 +11,7 @@ expression: empty_column_families "height_by_hash: no entries", "history_tree: no entries", "orchard_anchors: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_note_commitment_tree: no entries", "orchard_nullifiers: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_0.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_0.snap index 3c333a9fc43..abd4ae001ec 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_0.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_0.snap @@ -5,6 +5,7 @@ expression: empty_column_families [ "balance_by_transparent_addr: no entries", "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_1.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_1.snap index cb8ac5f6aed..8b114ddce4d 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_1.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_1.snap @@ -4,6 +4,7 @@ expression: empty_column_families --- [ "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_2.snap b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_2.snap index cb8ac5f6aed..8b114ddce4d 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_2.snap +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshots/empty_column_families@testnet_2.snap @@ -4,6 +4,7 @@ expression: empty_column_families --- [ "history_tree: no entries", + "orchard_issued_assets: no entries", "orchard_note_commitment_subtree: no entries", "orchard_nullifiers: no entries", "sapling_note_commitment_subtree: no entries", diff --git a/zebra-state/src/service/finalized_state/zebra_db/block.rs b/zebra-state/src/service/finalized_state/zebra_db/block.rs index 4dc3a801ef3..6f0d2340b91 100644 --- a/zebra-state/src/service/finalized_state/zebra_db/block.rs +++ b/zebra-state/src/service/finalized_state/zebra_db/block.rs @@ -463,7 +463,7 @@ impl DiskWriteBatch { // which is already present from height 1 to the first shielded transaction. // // In Zebra we include the nullifiers and note commitments in the genesis block because it simplifies our code. - self.prepare_shielded_transaction_batch(db, finalized)?; + self.prepare_shielded_transaction_batch(zebra_db, finalized)?; self.prepare_trees_batch(zebra_db, finalized, prev_note_commitment_trees)?; // # Consensus diff --git a/zebra-state/src/service/finalized_state/zebra_db/shielded.rs b/zebra-state/src/service/finalized_state/zebra_db/shielded.rs index 4bba75b1891..abd2e70431c 100644 --- a/zebra-state/src/service/finalized_state/zebra_db/shielded.rs +++ b/zebra-state/src/service/finalized_state/zebra_db/shielded.rs @@ -19,13 +19,16 @@ use std::{ use zebra_chain::{ block::Height, - orchard, + orchard::{self}, parallel::tree::NoteCommitmentTrees, sapling, sprout, subtree::{NoteCommitmentSubtreeData, NoteCommitmentSubtreeIndex}, transaction::Transaction, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::{AssetBase, AssetState, IssuedAssetsChange}; + use crate::{ request::{FinalizedBlock, Treestate}, service::finalized_state::{ @@ -36,11 +39,34 @@ use crate::{ BoxError, }; +#[cfg(feature = "tx_v6")] +use crate::service::finalized_state::TypedColumnFamily; + // Doc-only items #[allow(unused_imports)] use zebra_chain::subtree::NoteCommitmentSubtree; +#[cfg(feature = "tx_v6")] +/// The name of the chain value pools column family. +/// +/// This constant should be used so the compiler can detect typos. +pub const ISSUED_ASSETS: &str = "orchard_issued_assets"; + +#[cfg(feature = "tx_v6")] +/// The type for reading value pools from the database. +/// +/// This constant should be used so the compiler can detect incorrectly typed accesses to the +/// column family. +pub type IssuedAssetsCf<'cf> = TypedColumnFamily<'cf, AssetBase, AssetState>; + impl ZebraDb { + #[cfg(feature = "tx_v6")] + /// Returns a typed handle to the `history_tree` column family. + pub(crate) fn issued_assets_cf(&self) -> IssuedAssetsCf { + IssuedAssetsCf::new(&self.db, ISSUED_ASSETS) + .expect("column family was created when database was created") + } + // Read shielded methods /// Returns `true` if the finalized state contains `sprout_nullifier`. @@ -410,6 +436,12 @@ impl ZebraDb { Some(subtree_data.with_index(index)) } + #[cfg(feature = "tx_v6")] + /// Get the orchard issued asset state for the finalized tip. + pub fn issued_asset(&self, asset_base: &AssetBase) -> Option { + self.issued_assets_cf().zs_get(asset_base) + } + /// Returns the shielded note commitment trees of the finalized tip /// or the empty trees if the state is empty. /// Additionally, returns the sapling and orchard subtrees for the finalized tip if @@ -437,16 +469,19 @@ impl DiskWriteBatch { /// - Propagates any errors from updating note commitment trees pub fn prepare_shielded_transaction_batch( &mut self, - db: &DiskDb, + zebra_db: &ZebraDb, finalized: &FinalizedBlock, ) -> Result<(), BoxError> { let FinalizedBlock { block, .. } = finalized; // Index each transaction's shielded data for transaction in &block.transactions { - self.prepare_nullifier_batch(db, transaction)?; + self.prepare_nullifier_batch(&zebra_db.db, transaction)?; } + #[cfg(feature = "tx_v6")] + self.prepare_issued_assets_batch(zebra_db, finalized)?; + Ok(()) } @@ -480,6 +515,39 @@ impl DiskWriteBatch { Ok(()) } + #[cfg(feature = "tx_v6")] + /// Prepare a database batch containing `finalized.block`'s asset issuance + /// and return it (without actually writing anything). + /// + /// # Errors + /// + /// - This method doesn't currently return any errors, but it might in future + #[allow(clippy::unwrap_in_result)] + pub fn prepare_issued_assets_batch( + &mut self, + zebra_db: &ZebraDb, + finalized: &FinalizedBlock, + ) -> Result<(), BoxError> { + let mut batch = zebra_db.issued_assets_cf().with_batch_for_writing(self); + + let updated_issued_assets = + if let Some(updated_issued_assets) = finalized.issued_assets.as_ref() { + updated_issued_assets + } else { + &IssuedAssetsChange::from( + IssuedAssetsChange::from_transactions(&finalized.block.transactions) + .ok_or(BoxError::from("invalid issued assets changes"))?, + ) + .apply_with(|asset_base| zebra_db.issued_asset(&asset_base).unwrap_or_default()) + }; + + for (asset_base, updated_issued_asset_state) in updated_issued_assets.iter() { + batch = batch.zs_insert(asset_base, updated_issued_asset_state); + } + + Ok(()) + } + /// Prepare a database batch containing the note commitment and history tree updates /// from `finalized.block`, and return it (without actually writing anything). /// diff --git a/zebra-state/src/service/non_finalized_state.rs b/zebra-state/src/service/non_finalized_state.rs index 08d64455024..b0791fc8a62 100644 --- a/zebra-state/src/service/non_finalized_state.rs +++ b/zebra-state/src/service/non_finalized_state.rs @@ -325,6 +325,10 @@ impl NonFinalizedState { finalized_state, )?; + #[cfg(feature = "tx_v6")] + let issued_assets = + check::issuance::valid_burns_and_issuance(finalized_state, &new_chain, &prepared)?; + // Reads from disk check::anchors::block_sapling_orchard_anchors_refer_to_final_treestates( finalized_state, @@ -343,6 +347,9 @@ impl NonFinalizedState { let contextual = ContextuallyVerifiedBlock::with_block_and_spent_utxos( prepared.clone(), spent_utxos.clone(), + // TODO: Refactor this into repeated `With::with()` calls, see http_request_compatibility module. + #[cfg(feature = "tx_v6")] + issued_assets, ) .map_err(|value_balance_error| { ValidateContextError::CalculateBlockChainValueChange { diff --git a/zebra-state/src/service/non_finalized_state/chain.rs b/zebra-state/src/service/non_finalized_state/chain.rs index a002c301766..8071c199a5f 100644 --- a/zebra-state/src/service/non_finalized_state/chain.rs +++ b/zebra-state/src/service/non_finalized_state/chain.rs @@ -21,13 +21,18 @@ use zebra_chain::{ primitives::Groth16Proof, sapling, sprout, subtree::{NoteCommitmentSubtree, NoteCommitmentSubtreeData, NoteCommitmentSubtreeIndex}, - transaction::Transaction::*, - transaction::{self, Transaction}, + transaction::{ + self, + Transaction::{self, *}, + }, transparent, value_balance::ValueBalance, work::difficulty::PartialCumulativeWork, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::{AssetBase, AssetState, IssuedAssets, IssuedAssetsChange}; + use crate::{ request::Treestate, service::check, ContextuallyVerifiedBlock, HashOrHeight, OutputLocation, TransactionLocation, ValidateContextError, @@ -174,6 +179,12 @@ pub struct ChainInner { pub(crate) orchard_subtrees: BTreeMap>, + #[cfg(feature = "tx_v6")] + /// A partial map of `issued_assets` with entries for asset states that were updated in + /// this chain. + // TODO: Add reference to ZIP + pub(crate) issued_assets: HashMap, + // Nullifiers // /// The Sprout nullifiers revealed by `blocks`. @@ -237,6 +248,8 @@ impl Chain { orchard_anchors_by_height: Default::default(), orchard_trees_by_height: Default::default(), orchard_subtrees: Default::default(), + #[cfg(feature = "tx_v6")] + issued_assets: Default::default(), sprout_nullifiers: Default::default(), sapling_nullifiers: Default::default(), orchard_nullifiers: Default::default(), @@ -937,6 +950,49 @@ impl Chain { } } + #[cfg(feature = "tx_v6")] + /// Returns the Orchard issued asset state if one is present in + /// the chain for the provided asset base. + pub fn issued_asset(&self, asset_base: &AssetBase) -> Option { + self.issued_assets.get(asset_base).cloned() + } + + #[cfg(feature = "tx_v6")] + /// Remove the History tree index at `height`. + fn revert_issued_assets( + &mut self, + position: RevertPosition, + issued_assets: &IssuedAssets, + transactions: &[Arc], + ) { + if position == RevertPosition::Root { + trace!(?position, "removing unmodified issued assets"); + for (asset_base, &asset_state) in issued_assets.iter() { + if self + .issued_asset(asset_base) + .expect("issued assets for chain should include those in all blocks") + == asset_state + { + self.issued_assets.remove(asset_base); + } + } + } else { + trace!(?position, "reverting changes to issued assets"); + for issued_assets_change in IssuedAssetsChange::from_transactions(transactions) + .expect("blocks in chain state must be valid") + .iter() + .rev() + { + for (asset_base, change) in issued_assets_change.iter() { + self.issued_assets + .entry(asset_base) + .or_default() + .revert_change(change); + } + } + } + } + /// Adds the Orchard `tree` to the tree and anchor indexes at `height`. /// /// `height` can be either: @@ -1439,6 +1495,10 @@ impl Chain { self.add_history_tree(height, history_tree); + #[cfg(feature = "tx_v6")] + self.issued_assets + .extend(contextually_valid.issued_assets.clone()); + Ok(()) } @@ -1677,6 +1737,9 @@ impl UpdateWith for Chain { &contextually_valid.chain_value_pool_change, ); + #[cfg(feature = "tx_v6")] + let issued_assets = &contextually_valid.issued_assets; + // remove the blocks hash from `height_by_hash` assert!( self.height_by_hash.remove(&hash).is_some(), @@ -1696,21 +1759,22 @@ impl UpdateWith for Chain { for (transaction, transaction_hash) in block.transactions.iter().zip(transaction_hashes.iter()) { - let ( - inputs, - outputs, - joinsplit_data, - sapling_shielded_data_per_spend_anchor, - sapling_shielded_data_shared_anchor, - orchard_shielded_data, - ) = match transaction.deref() { + let transaction_data = match transaction.deref() { V4 { inputs, outputs, joinsplit_data, sapling_shielded_data, .. - } => (inputs, outputs, joinsplit_data, sapling_shielded_data, &None, &None), + } => ( + inputs, + outputs, + joinsplit_data, + sapling_shielded_data, + &None, + &None, + #[cfg(feature = "tx_v6")] + &None), V5 { inputs, outputs, @@ -1724,13 +1788,15 @@ impl UpdateWith for Chain { &None, sapling_shielded_data, orchard_shielded_data, + #[cfg(feature = "tx_v6")] + &None, ), #[cfg(feature = "tx_v6")] V6 { inputs, outputs, sapling_shielded_data, - orchard_shielded_data: _, + orchard_shielded_data, .. } => ( inputs, @@ -1738,14 +1804,35 @@ impl UpdateWith for Chain { &None, &None, sapling_shielded_data, - // FIXME: support V6 shielded data? - &None, //orchard_shielded_data, + &None, + orchard_shielded_data, ), V1 { .. } | V2 { .. } | V3 { .. } => unreachable!( "older transaction versions only exist in finalized blocks, because of the mandatory canopy checkpoint", ), }; + #[cfg(not(feature = "tx_v6"))] + let ( + inputs, + outputs, + joinsplit_data, + sapling_shielded_data_per_spend_anchor, + sapling_shielded_data_shared_anchor, + orchard_shielded_data_vanilla, + ) = transaction_data; + + #[cfg(feature = "tx_v6")] + let ( + inputs, + outputs, + joinsplit_data, + sapling_shielded_data_per_spend_anchor, + sapling_shielded_data_shared_anchor, + orchard_shielded_data_vanilla, + orchard_shielded_data_zsa, + ) = transaction_data; + // remove the utxos this produced self.revert_chain_with(&(outputs, transaction_hash, new_outputs), position); // reset the utxos this consumed @@ -1762,7 +1849,9 @@ impl UpdateWith for Chain { self.revert_chain_with(joinsplit_data, position); self.revert_chain_with(sapling_shielded_data_per_spend_anchor, position); self.revert_chain_with(sapling_shielded_data_shared_anchor, position); - self.revert_chain_with(orchard_shielded_data, position); + self.revert_chain_with(orchard_shielded_data_vanilla, position); + #[cfg(feature = "tx_v6")] + self.revert_chain_with(orchard_shielded_data_zsa, position); } // TODO: move these to the shielded UpdateWith.revert...()? @@ -1773,6 +1862,10 @@ impl UpdateWith for Chain { // TODO: move this to the history tree UpdateWith.revert...()? self.remove_history_tree(position, height); + #[cfg(feature = "tx_v6")] + // revert the issued assets map, if needed + self.revert_issued_assets(position, issued_assets, &block.transactions); + // revert the chain value pool balances, if needed self.revert_chain_with(chain_value_pool_change, position); } diff --git a/zebra-state/src/service/non_finalized_state/tests/prop.rs b/zebra-state/src/service/non_finalized_state/tests/prop.rs index 2a1adf65c20..f28689c9722 100644 --- a/zebra-state/src/service/non_finalized_state/tests/prop.rs +++ b/zebra-state/src/service/non_finalized_state/tests/prop.rs @@ -52,6 +52,8 @@ fn push_genesis_chain() -> Result<()> { ContextuallyVerifiedBlock::with_block_and_spent_utxos( block, only_chain.unspent_utxos(), + #[cfg(feature = "tx_v6")] + Default::default(), ) .map_err(|e| (e, chain_values.clone())) .expect("invalid block value pool change"); @@ -148,6 +150,8 @@ fn forked_equals_pushed_genesis() -> Result<()> { let block = ContextuallyVerifiedBlock::with_block_and_spent_utxos( block, partial_chain.unspent_utxos(), + #[cfg(feature = "tx_v6")] + Default::default() )?; partial_chain = partial_chain .push(block) @@ -166,8 +170,12 @@ fn forked_equals_pushed_genesis() -> Result<()> { ); for block in chain.iter().cloned() { - let block = - ContextuallyVerifiedBlock::with_block_and_spent_utxos(block, full_chain.unspent_utxos())?; + let block = ContextuallyVerifiedBlock::with_block_and_spent_utxos( + block, + full_chain.unspent_utxos(), + #[cfg(feature = "tx_v6")] + Default::default() + )?; // Check some properties of the genesis block and don't push it to the chain. if block.height == block::Height(0) { @@ -210,7 +218,9 @@ fn forked_equals_pushed_genesis() -> Result<()> { // same original full chain. for block in chain.iter().skip(fork_at_count).cloned() { let block = - ContextuallyVerifiedBlock::with_block_and_spent_utxos(block, forked.unspent_utxos())?; + ContextuallyVerifiedBlock::with_block_and_spent_utxos(block, forked.unspent_utxos(), + #[cfg(feature = "tx_v6")] + Default::default())?; forked = forked.push(block).expect("forked chain push is valid"); } diff --git a/zebra-state/src/service/read.rs b/zebra-state/src/service/read.rs index 0188ca1bf5e..1450a390348 100644 --- a/zebra-state/src/service/read.rs +++ b/zebra-state/src/service/read.rs @@ -38,6 +38,10 @@ pub use find::{ find_chain_headers, hash_by_height, height_by_hash, next_median_time_past, non_finalized_state_contains_block_hash, tip, tip_height, tip_with_value_balance, }; + +#[cfg(feature = "tx_v6")] +pub use find::asset_state; + pub use tree::{orchard_subtrees, orchard_tree, sapling_subtrees, sapling_tree}; #[cfg(any(test, feature = "proptest-impl"))] diff --git a/zebra-state/src/service/read/find.rs b/zebra-state/src/service/read/find.rs index e9d557dbfb2..e87c396199f 100644 --- a/zebra-state/src/service/read/find.rs +++ b/zebra-state/src/service/read/find.rs @@ -25,6 +25,9 @@ use zebra_chain::{ value_balance::ValueBalance, }; +#[cfg(feature = "tx_v6")] +use zebra_chain::orchard_zsa::{AssetBase, AssetState}; + use crate::{ constants, service::{ @@ -679,3 +682,14 @@ pub(crate) fn calculate_median_time_past(relevant_chain: Vec>) -> Dat DateTime32::try_from(median_time_past).expect("valid blocks have in-range times") } + +#[cfg(feature = "tx_v6")] +/// Return the [`AssetState`] for the provided [`AssetBase`], if it exists in the provided chain. +pub fn asset_state(chain: Option, db: &ZebraDb, asset_base: &AssetBase) -> Option +where + C: AsRef, +{ + chain + .and_then(|chain| chain.as_ref().issued_asset(asset_base)) + .or_else(|| db.issued_asset(asset_base)) +} diff --git a/zebra-test/src/vectors/orchard-zsa-workflow-blocks-1.txt b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-1.txt new file mode 100644 index 00000000000..4fa4c2dcba9 --- /dev/null +++ b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-1.txt @@ -0,0 +1 @@ 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 diff --git a/zebra-test/src/vectors/orchard-zsa-workflow-blocks-2.txt b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-2.txt new file mode 100644 index 00000000000..a04d0c7c269 --- /dev/null +++ b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-2.txt @@ -0,0 +1 @@ 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 diff --git a/zebra-test/src/vectors/orchard-zsa-workflow-blocks-3.txt b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-3.txt new file mode 100644 index 00000000000..a610fad2d4d --- /dev/null +++ b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-3.txt @@ -0,0 +1 @@ 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 diff --git a/zebra-test/src/vectors/orchard-zsa-workflow-blocks-4.txt b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-4.txt new file mode 100644 index 00000000000..68d31bc1c44 --- /dev/null +++ b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-4.txt @@ -0,0 +1,2 @@ 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 + diff --git a/zebra-test/src/vectors/orchard-zsa-workflow-blocks-5.txt b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-5.txt new file mode 100644 index 00000000000..d90ef979490 --- /dev/null +++ b/zebra-test/src/vectors/orchard-zsa-workflow-blocks-5.txt @@ -0,0 +1 @@ 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 diff --git a/zebra-test/src/vectors/orchard_zsa_workflow_blocks.rs b/zebra-test/src/vectors/orchard_zsa_workflow_blocks.rs index 733052cf920..6bb9118fc4c 100644 --- a/zebra-test/src/vectors/orchard_zsa_workflow_blocks.rs +++ b/zebra-test/src/vectors/orchard_zsa_workflow_blocks.rs @@ -1,23 +1,55 @@ -//! OrchardZSA test vectors +//! OrchardZSA workflow test blocks + +#![allow(missing_docs)] use hex::FromHex; use lazy_static::lazy_static; +/// Represents a serialized block and its validity status. +pub struct OrchardWorkflowBlock { + /// Serialized byte data of the block. + pub bytes: Vec, + /// Indicates whether the block is valid. + pub is_valid: bool, +} + +fn decode_bytes(hex: &str) -> Vec { + >::from_hex((hex).trim()).expect("Block bytes are in valid hex representation") +} + lazy_static! { -/// Test blocks for a Zcash Shielded Assets (ZSA) workflow. -/// The sequence demonstrates issuing, transferring and burning a custom -/// asset, then finalising the issuance and attempting an extra issue. -pub static ref ORCHARD_ZSA_WORKFLOW_BLOCKS: [Vec; 5] = [ + /// Test blocks for a Zcash Shielded Assets (ZSA) workflow. + /// The sequence demonstrates issuing, transferring and burning a custom + /// asset, then finalising the issuance and attempting an extra issue. + pub static ref ORCHARD_ZSA_WORKFLOW_BLOCKS: Vec = vec![ // Issue: 1000 - "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", + OrchardWorkflowBlock { + bytes: decode_bytes(include_str!("orchard-zsa-workflow-blocks-1.txt")), + is_valid: true + }, + // Transfer - "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", + OrchardWorkflowBlock { + bytes: decode_bytes(include_str!("orchard-zsa-workflow-blocks-2.txt")), + is_valid: true + }, + // Burn: 7, Burn: 2 - "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", + OrchardWorkflowBlock { + bytes: decode_bytes(include_str!("orchard-zsa-workflow-blocks-3.txt")), + is_valid: true + }, + // Issue: finalize - "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", + OrchardWorkflowBlock { + bytes: decode_bytes(include_str!("orchard-zsa-workflow-blocks-4.txt")), + is_valid: true + }, + // Try to issue: 2000 - "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", - ] - .map(|hex| >::from_hex(hex).expect("Block bytes are in valid hex representation")); + OrchardWorkflowBlock { + bytes: decode_bytes(include_str!("orchard-zsa-workflow-blocks-5.txt")), + is_valid: false + }, + ]; } From 4b57e610df9a92c40c94f8f778f62cc20e398ad0 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Wed, 3 Dec 2025 12:21:56 +0100 Subject: [PATCH 47/49] Reorder fields in fmt::Display for ActionGroup according the spec layout --- zebra-chain/src/orchard/shielded_data.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index df6b8ffb206..912518e0b12 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -91,18 +91,19 @@ impl fmt::Display for ActionGroup { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut fmter = f.debug_struct("orchard::ActionGroup"); - // FIXME: reorder fields here according the struct/spec? - fmter.field("actions", &self.actions.len()); fmter.field("flags", &self.flags); - fmter.field("proof_len", &self.proof.zcash_serialized_size()); - - fmter.field("shared_anchor", &self.shared_anchor); + #[cfg(feature = "tx_v6")] + fmter.field("expiry_height", &self.expiry_height); #[cfg(feature = "tx_v6")] fmter.field("burn", &self.burn.as_ref().len()); + fmter.field("proof_len", &self.proof.zcash_serialized_size()); + + fmter.field("shared_anchor", &self.shared_anchor); + fmter.finish() } } From 47287e36fcb4cfa2e97d9bb90e7db56ad6e45a3e Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Wed, 3 Dec 2025 13:38:03 +0100 Subject: [PATCH 48/49] Fix compilation error im zebra-chain --- zebra-chain/src/transaction.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs index 1e951030a34..b7a3b9ccb5d 100644 --- a/zebra-chain/src/transaction.rs +++ b/zebra-chain/src/transaction.rs @@ -1141,11 +1141,11 @@ impl Transaction { Transaction::V6 { orchard_shielded_data, .. - } => Box::new( - orchard_shielded_data + } => Box::new(orchard_shielded_data.iter().flat_map(|data| { + data.action_groups .iter() - .flat_map(|data| data.burn.as_ref().iter()), - ), + .flat_map(|action_group| action_group.burn.as_ref().iter()) + })), } } From 3702878dd75d37c71a3867d66680c3201fb405b7 Mon Sep 17 00:00:00 2001 From: Dmitry Demin Date: Wed, 3 Dec 2025 16:01:28 +0100 Subject: [PATCH 49/49] Additional refactoring --- zebra-chain/src/orchard/shielded_data.rs | 31 ++++-- .../src/primitives/zcash_note_encryption.rs | 4 +- zebra-chain/src/transaction.rs | 100 ++++++++++++------ zebra-consensus/src/primitives/halo2.rs | 2 +- 4 files changed, 94 insertions(+), 43 deletions(-) diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs index 912518e0b12..458094cdad1 100644 --- a/zebra-chain/src/orchard/shielded_data.rs +++ b/zebra-chain/src/orchard/shielded_data.rs @@ -30,12 +30,18 @@ use super::{OrchardVanilla, ShieldedDataFlavor}; // FIXME: wrap all ActionGroup usages with tx_v6 feature flag? /// Action Group description. -#[cfg(feature = "tx_v6")] #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)] -#[serde(bound( - serialize = "Flavor::EncryptedNote: serde::Serialize, Flavor::BurnType: serde::Serialize", - deserialize = "Flavor::BurnType: serde::Deserialize<'de>" -))] +#[cfg_attr( + not(feature = "tx_v6"), + serde(bound(serialize = "Flavor::EncryptedNote: serde::Serialize")) +)] +#[cfg_attr( + feature = "tx_v6", + serde(bound( + serialize = "Flavor::EncryptedNote: serde::Serialize, Flavor::BurnType: serde::Serialize", + deserialize = "Flavor::BurnType: serde::Deserialize<'de>" + )) +)] pub struct ActionGroup { /// The orchard flags for this transaction. /// Denoted as `flagsOrchard` in the spec. @@ -72,10 +78,17 @@ impl ActionGroup { /// A bundle of [`Action`] descriptions and signature data. #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)] -#[serde(bound( - serialize = "Flavor::EncryptedNote: serde::Serialize, Flavor::BurnType: serde::Serialize", - deserialize = "Flavor::BurnType: serde::Deserialize<'de>" -))] +#[cfg_attr( + not(feature = "tx_v6"), + serde(bound(serialize = "Flavor::EncryptedNote: serde::Serialize")) +)] +#[cfg_attr( + feature = "tx_v6", + serde(bound( + serialize = "Flavor::EncryptedNote: serde::Serialize, Flavor::BurnType: serde::Serialize", + deserialize = "Flavor::BurnType: serde::Deserialize<'de>" + )) +)] pub struct ShieldedData { /// Action Group descriptions. /// Denoted as `vActionGroupsOrchard` in the spec (ZIP 230). diff --git a/zebra-chain/src/primitives/zcash_note_encryption.rs b/zebra-chain/src/primitives/zcash_note_encryption.rs index c030a13aa26..a43e2f411ab 100644 --- a/zebra-chain/src/primitives/zcash_note_encryption.rs +++ b/zebra-chain/src/primitives/zcash_note_encryption.rs @@ -70,8 +70,8 @@ pub fn decrypts_successfully(transaction: &Transaction, network: &Network, heigh } /// Checks if all actions in an Orchard bundle decrypt successfully. -fn orchard_bundle_decrypts_successfully( - bundle: &Bundle, +fn orchard_bundle_decrypts_successfully( + bundle: &Bundle, ) -> bool { bundle.actions().iter().all(|act| { zcash_note_encryption::try_output_recovery_with_ovk( diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs index a10cb478848..ef814b85714 100644 --- a/zebra-chain/src/transaction.rs +++ b/zebra-chain/src/transaction.rs @@ -204,32 +204,6 @@ impl fmt::Display for Transaction { } } -// Macro to get a specific field from an Orchard shielded data struct. -// Returns `None` for transaction versions that don't support Orchard (V1-V4). -// This avoids repeating the same match block pattern across multiple accessor methods. -macro_rules! orchard_shielded_data_map { - ($self:expr, $data:ident => $body:expr) => { - match $self { - // No Orchard shielded data - Transaction::V1 { .. } - | Transaction::V2 { .. } - | Transaction::V3 { .. } - | Transaction::V4 { .. } => None, - - Transaction::V5 { - orchard_shielded_data, - .. - } => orchard_shielded_data.as_ref().map(|$data| $body), - - #[cfg(feature = "tx_v6")] - Transaction::V6 { - orchard_shielded_data, - .. - } => orchard_shielded_data.as_ref().map(|$data| $body), - } - }; -} - impl Transaction { // identifiers and hashes @@ -1112,7 +1086,27 @@ impl Transaction { /// Access the [`orchard::Flags`] in this transaction, if there is any, /// regardless of version. pub fn orchard_flags_union(&self) -> Option { - orchard_shielded_data_map!(self, d => d.flags_union()) + match self { + Transaction::V1 { .. } + | Transaction::V2 { .. } + | Transaction::V3 { .. } + | Transaction::V4 { .. } => None, + + Transaction::V5 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.flags_union()), + + #[cfg(feature = "tx_v6")] + Transaction::V6 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.flags_union()), + } } /// Access the [`orchard::tree::Root`] in this transaction, if there is any, @@ -1132,6 +1126,7 @@ impl Transaction { .iter() .flat_map(orchard::ShieldedData::shared_anchors), ), + #[cfg(feature = "tx_v6")] Transaction::V6 { orchard_shielded_data, @@ -1147,7 +1142,31 @@ impl Transaction { /// Return if the transaction has any Orchard shielded data, /// regardless of version. pub fn has_orchard_shielded_data(&self) -> bool { - orchard_shielded_data_map!(self, d => d.value_balance()).is_some() + // FIXME: avoid code duplication with orchard_value_balance + let value_balance = match self { + // No Orchard shielded data + Transaction::V1 { .. } + | Transaction::V2 { .. } + | Transaction::V3 { .. } + | Transaction::V4 { .. } => None, + + Transaction::V5 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.value_balance()), + + #[cfg(feature = "tx_v6")] + Transaction::V6 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.value_balance()), + }; + + value_balance.is_some() } // value balances @@ -1402,10 +1421,29 @@ impl Transaction { /// /// pub fn orchard_value_balance(&self) -> ValueBalance { - let orchard_value_balance = - orchard_shielded_data_map!(self, d => d.value_balance()).unwrap_or_else(Amount::zero); + let value_balance = match self { + Transaction::V1 { .. } + | Transaction::V2 { .. } + | Transaction::V3 { .. } + | Transaction::V4 { .. } => None, + + Transaction::V5 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.value_balance()), + + #[cfg(feature = "tx_v6")] + Transaction::V6 { + orchard_shielded_data, + .. + } => orchard_shielded_data + .as_ref() + .map(|data| data.value_balance()), + }; - ValueBalance::from_orchard_amount(orchard_value_balance) + ValueBalance::from_orchard_amount(value_balance.unwrap_or_else(Amount::zero)) } /// Returns the value balances for this transaction using the provided transparent outputs. diff --git a/zebra-consensus/src/primitives/halo2.rs b/zebra-consensus/src/primitives/halo2.rs index a4623026b55..8a0e71be596 100644 --- a/zebra-consensus/src/primitives/halo2.rs +++ b/zebra-consensus/src/primitives/halo2.rs @@ -148,7 +148,7 @@ impl From<&ActionGroup> for Item { let anchor = tree::Anchor::from_bytes(action_group.shared_anchor.into()).unwrap(); let flags = orchard::bundle::Flags::from_byte(action_group.flags.bits()) - .expect("failed to convert flags: shielded_data.flags contains unexpected bits that are not valid in orchard::bundle::Flags"); + .expect("failed to convert flags: action_group.flags contains unexpected bits that are not valid in orchard::bundle::Flags"); let instances = action_group .actions()