fix: merge conflicts

Author: golddydev

Makefile

@@ -6,6 +6,8 @@ SHELL := bash
 CARGO := cargo
 PYTHON := python3
 PROCESS_PKG := acropolis_process_omnibus
+LOG_LEVEL ?= info
+
 
 # Test snapshots
 SNAPSHOT_SMALL ?= tests/fixtures/snapshot-small.cbor
@@ -28,6 +30,7 @@ help:
 	@echo "Build & Test:"
 	@echo "  all                      Format, lint, and test"
 	@echo "  build                    Build the omnibus process"
+	@echo "  run 					  Run the omnibus"
 	@echo "  test                     Run all tests"
 	@echo "  fmt                      Run cargo fmt"
 	@echo "  clippy                   Run cargo clippy -D warnings"
@@ -37,9 +40,11 @@ help:
 	@echo ""
 	@echo "Variables:"
 	@echo "  SNAPSHOT=<path>          Path to snapshot file (default: Conway epoch 507)"
+	@echo "  LOG_LEVEL=<level>        Set log level (default: info, options: error, warn, info, debug, trace)"
 	@echo ""
 	@echo "Examples:"
 	@echo "  make snap-test-streaming"
+	@echo "  make run LOG_LEVEL=debug"
 	@echo "  make snap-test-streaming SNAPSHOT=path/to/snapshot.cbor"
 
 all: fmt clippy test
@@ -51,7 +56,7 @@ test:
 	$(CARGO) test
 
 run:
-	$(CARGO) run -p $(PROCESS_PKG)
+	cd processes/omnibus && RUST_LOG=$(LOG_LEVEL) $(CARGO) run --release --bin $(PROCESS_PKG)
 
 fmt:
 	$(CARGO) fmt --all

codec/src/map_parameters.rs

@@ -18,6 +18,7 @@ use acropolis_common::{
     rational_number::RationalNumber,
     *,
 };
+use pallas_primitives::conway::PseudoScript;
 use std::collections::{HashMap, HashSet};
 
 /// Map Pallas Network to our NetworkId
@@ -1100,3 +1101,21 @@ pub fn map_datum(datum: &Option<conway::MintedDatumOption>) -> Option<Datum> {
         None => None,
     }
 }
+
+pub fn map_reference_script(script: &Option<conway::MintedScriptRef>) -> Option<ReferenceScript> {
+    match script {
+        Some(PseudoScript::NativeScript(script)) => {
+            Some(ReferenceScript::Native(script.raw_cbor().to_vec()))
+        }
+        Some(PseudoScript::PlutusV1Script(script)) => {
+            Some(ReferenceScript::PlutusV1(script.as_ref().to_vec()))
+        }
+        Some(PseudoScript::PlutusV2Script(script)) => {
+            Some(ReferenceScript::PlutusV2(script.as_ref().to_vec()))
+        }
+        Some(PseudoScript::PlutusV3Script(script)) => {
+            Some(ReferenceScript::PlutusV3(script.as_ref().to_vec()))
+        }
+        None => None,
+    }
+}

common/src/address.rs

@@ -3,6 +3,7 @@
 #![allow(dead_code)]
 
 use crate::cip19::{VarIntDecoder, VarIntEncoder};
+use crate::hash::Hash;
 use crate::{Credential, KeyHash, NetworkId, ScriptHash, StakeCredential};
 use anyhow::{anyhow, bail, Result};
 use crc::{Crc, CRC_32_ISO_HDLC};
@@ -147,10 +148,12 @@ pub struct ShelleyAddressPointer {
     serde::Deserialize,
     minicbor::Encode,
     minicbor::Decode,
+    Default,
 )]
 pub enum ShelleyAddressDelegationPart {
     /// No delegation (enterprise addresses)
     #[n(0)]
+    #[default]
     None,
 
     /// Delegation to stake key
@@ -166,12 +169,6 @@ pub enum ShelleyAddressDelegationPart {
     Pointer(#[n(0)] ShelleyAddressPointer),
 }
 
-impl Default for ShelleyAddressDelegationPart {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 /// A Shelley-era address
 #[derive(
     Debug,
@@ -294,7 +291,7 @@ impl ShelleyAddress {
         Ok(bech32::encode::<bech32::Bech32>(hrp, &data)?)
     }
 
-    pub fn to_bytes_key(&self) -> Result<Vec<u8>> {
+    pub fn to_bytes_key(&self) -> Vec<u8> {
         let network_bits = match self.network {
             NetworkId::Mainnet => 1u8,
             NetworkId::Testnet => 0u8,
@@ -307,8 +304,10 @@ impl ShelleyAddress {
 
         let mut data = Vec::new();
 
-        let build_header =
-            |variant: u8| -> u8 { network_bits | (payment_bits << 4) | (variant << 5) };
+        let build_header = |delegation_bits: u8| -> u8 {
+            let addr_type = ((delegation_bits & 0x03) << 1) | (payment_bits & 0x01);
+            (addr_type << 4) | (network_bits & 0x0F)
+        };
 
         match &self.delegation {
             ShelleyAddressDelegationPart::None => {
@@ -341,7 +340,76 @@ impl ShelleyAddress {
             }
         }
 
-        Ok(data)
+        data
+    }
+
+    pub fn from_bytes_key(data: &[u8]) -> Result<Self> {
+        if data.is_empty() {
+            return Err(anyhow!("empty address bytes"));
+        }
+
+        let header = data[0];
+
+        if header & 0x80 != 0 {
+            return Err(anyhow!("invalid header: high bit set"));
+        }
+
+        let network = match header & 0x0F {
+            0 => NetworkId::Testnet,
+            1 => NetworkId::Mainnet,
+            _ => return Err(anyhow!("invalid network bits in header")),
+        };
+
+        let addr_type = (header >> 4) & 0x0F;
+
+        let payment_bits = addr_type & 0x01;
+        let delegation_bits = (addr_type >> 1) & 0x03;
+
+        let payment_hash = {
+            let mut arr = [0u8; 28];
+            arr.copy_from_slice(&data[1..29]);
+            Hash::<28>::new(arr)
+        };
+
+        let payment = match payment_bits {
+            0 => ShelleyAddressPaymentPart::PaymentKeyHash(payment_hash),
+            1 => ShelleyAddressPaymentPart::ScriptHash(payment_hash),
+            _ => return Err(anyhow!("invalid payment bits")),
+        };
+
+        let delegation = match delegation_bits {
+            0 => {
+                let mut arr = [0u8; 28];
+                arr.copy_from_slice(&data[29..57]);
+                ShelleyAddressDelegationPart::StakeKeyHash(Hash::<28>::new(arr))
+            }
+            1 => {
+                let mut arr = [0u8; 28];
+                arr.copy_from_slice(&data[29..57]);
+                ShelleyAddressDelegationPart::ScriptHash(Hash::<28>::new(arr))
+            }
+            2 => {
+                let mut decoder = VarIntDecoder::new(&data[29..]);
+                let slot = decoder.read()?;
+                let tx_index = decoder.read()?;
+                let cert_index = decoder.read()?;
+
+                ShelleyAddressDelegationPart::Pointer(ShelleyAddressPointer {
+                    slot,
+                    tx_index,
+                    cert_index,
+                })
+            }
+            3 => ShelleyAddressDelegationPart::None,
+
+            _ => return Err(anyhow!("invalid delegation bits")),
+        };
+
+        Ok(ShelleyAddress {
+            network,
+            payment,
+            delegation,
+        })
     }
 
     pub fn stake_address_string(&self) -> Result<Option<String>> {
@@ -547,20 +615,15 @@ impl Default for StakeAddress {
 }
 
 /// A Cardano address
-#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, Default)]
 pub enum Address {
+    #[default]
     None,
     Byron(ByronAddress),
     Shelley(ShelleyAddress),
     Stake(StakeAddress),
 }
 
-impl Default for Address {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 impl Address {
     /// Get the stake pointer if there is one
     pub fn get_pointer(&self) -> Option<ShelleyAddressPointer> {
@@ -600,7 +663,7 @@ impl Address {
         match self {
             Address::Byron(b) => b.to_bytes_key(),
 
-            Address::Shelley(s) => s.to_bytes_key(),
+            Address::Shelley(s) => Ok(s.to_bytes_key()),
 
             Address::Stake(stake) => stake.to_bytes_key(),
 
@@ -652,7 +715,7 @@ impl PartialOrd for BechOrdAddress {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::crypto::keyhash_224;
+    use crate::{crypto::keyhash_224, hash::Hash};
     use minicbor::{Decode, Encode};
 
     #[test]
@@ -1047,4 +1110,104 @@ mod tests {
         let result = StakeAddress::decode(&mut decoder, &mut ());
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_shelley_address_to_from_bytes_key_roundtrip() {
+        let payment_hash = Hash::new([0x11; 28]);
+        let stake_hash = Hash::new([0x22; 28]);
+        let script_hash = Hash::new([0x33; 28]);
+
+        // (KeyHash, StakeKeyHash)
+        let type_1 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::PaymentKeyHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::StakeKeyHash(stake_hash),
+        };
+        let bytes = type_1.to_bytes_key();
+        assert_eq!(bytes[0], 0x01);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode base");
+        assert_eq!(type_1, decoded);
+
+        // (ScriptKeyHash, StakeKeyHash)
+        let type_2 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::ScriptHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::StakeKeyHash(stake_hash),
+        };
+        let bytes = type_2.to_bytes_key();
+        assert_eq!(bytes[0], 0x11);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode base");
+        assert_eq!(type_2, decoded);
+
+        // (KeyHash, ScriptHash)
+        let type_3 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::PaymentKeyHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::ScriptHash(stake_hash),
+        };
+        let bytes = type_3.to_bytes_key();
+        assert_eq!(bytes[0], 0x21);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode base");
+        assert_eq!(type_3, decoded);
+
+        // (ScriptHash, ScriptHash)
+        let type_4 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::ScriptHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::ScriptHash(script_hash),
+        };
+        let bytes = type_4.to_bytes_key();
+        assert_eq!(bytes[0], 0x31);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode script");
+        assert_eq!(type_4, decoded);
+
+        // (KeyHash, Pointer)
+        let pointer = ShelleyAddressPointer {
+            slot: 1234,
+            tx_index: 56,
+            cert_index: 2,
+        };
+        let type_5 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::PaymentKeyHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::Pointer(pointer.clone()),
+        };
+        let bytes = type_5.to_bytes_key();
+        assert_eq!(bytes[0], 0x41);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode pointer");
+        assert_eq!(type_5, decoded);
+
+        // (ScriptHash, Pointer)
+        let type_6 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::ScriptHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::Pointer(pointer),
+        };
+        let bytes = type_6.to_bytes_key();
+        assert_eq!(bytes[0], 0x51);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode pointer");
+        assert_eq!(type_6, decoded);
+
+        // (KeyHash, None)
+        let type_7 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::PaymentKeyHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::None,
+        };
+        let bytes = type_7.to_bytes_key();
+        assert_eq!(bytes[0], 0x61);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode none");
+        assert_eq!(type_7, decoded);
+
+        // (ScriptHash, None)
+        let type_8 = ShelleyAddress {
+            network: NetworkId::Mainnet,
+            payment: ShelleyAddressPaymentPart::ScriptHash(payment_hash),
+            delegation: ShelleyAddressDelegationPart::None,
+        };
+        let bytes = type_8.to_bytes_key();
+        assert_eq!(bytes[0], 0x71);
+        let decoded = ShelleyAddress::from_bytes_key(&bytes).expect("decode none");
+        assert_eq!(type_8, decoded);
+    }
 }

common/src/lib.rs

@@ -15,6 +15,7 @@ pub mod protocol_params;
 pub mod queries;
 pub mod rational_number;
 pub mod resolver;
+pub mod rest_error;
 pub mod rest_helper;
 pub mod serialization;
 pub mod snapshot;

common/src/messages.rs

@@ -311,6 +311,7 @@ pub enum CardanoMessage {
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum SnapshotMessage {
+    Startup, // subscribers should listen for incremental snapshot data
     Bootstrap(SnapshotStateMessage),
     DumpRequest(SnapshotDumpMessage),
     Dump(SnapshotStateMessage),