Merge remote-tracking branch 'origin/main' into stevan/sim-readme

Signed-off-by: Stevan A <stevana@users.noreply.github.com>

Author: stevana

.github/workflows/CI.yml

@@ -161,8 +161,6 @@ jobs:
     name: Snapshots
     runs-on: ubuntu-latest
     if: ${{ !github.event.pull_request.draft }}
-    env:
-      AMARU_PEER_ADDRESS: 127.0.0.1:3001
     strategy:
       matrix:
         network:

Cargo.toml

@@ -148,3 +148,11 @@ debug = true
 [profile.release]
 lto = true
 codegen-units = 1
+
+[workspace.metadata.cross.target.aarch64-unknown-linux-musl]
+pre-build = [
+    "apt update",
+    "apt install -y libclang-dev"
+]
+[workspace.metadata.cross.target.aarch64-unknown-linux-musl.env]
+passthrough = ["LIBCLANG_PATH=/usr/lib/llvm-10/lib"]

Makefile

@@ -4,7 +4,7 @@ DATA_FOLDER := $(CONFIG_FOLDER)/$(NETWORK)
 SNAPSHOTS_FILE := $(DATA_FOLDER)/snapshots.json
 NONCES_FILE := $(DATA_FOLDER)/nonces.json
 HEADERS_FILE := $(DATA_FOLDER)/headers.json
-AMARU_PEER_ADDRESS ?= 127.0.0.1:3001
+PEER_ADDRESS ?= 127.0.0.1:3001
 HASKELL_NODE_CONFIG_DIR ?= cardano-node-config
 DEMO_TARGET_EPOCH ?= 182
 HASKELL_NODE_CONFIG_SOURCE := https://book.world.dev.cardano.org/environments
@@ -46,14 +46,14 @@ import-snapshots: snapshots/$(NETWORK) ## Import snapshots for demo
 		--ledger-dir "$(LEDGER_DIR)" \
 		$$SNAPSHOT_ARGS
 
-import-headers: ## Import headers from $AMARU_PEER_ADDRESS for demo
+import-headers: ## Import headers from $PEER_ADDRESS for demo
 	@if [ ! -f "$(HEADERS_FILE)" ]; then echo "HEADERS_FILE not found: $(HEADERS_FILE)"; exit 1; fi; \
 	HEADERS=$$(jq -r '.[]' $(HEADERS_FILE)); \
 	for HEADER in $$HEADERS; do \
 		cargo run --profile $(BUILD_PROFILE) -- import-headers \
 			--network $(NETWORK) \
 			--chain-dir $(CHAIN_DIR) \
-			--peer-address $(AMARU_PEER_ADDRESS) \
+			--peer-address $(PEER_ADDRESS) \
 			--starting-point $$HEADER \
 			--count 2; \
 	done
@@ -83,7 +83,7 @@ clear-dbs: ## Clear the databases
 
 bootstrap: clear-dbs ## Bootstrap the node from scratch
 	cargo run --profile $(BUILD_PROFILE) -- bootstrap \
-		--peer-address $(AMARU_PEER_ADDRESS) \
+		--peer-address $(PEER_ADDRESS) \
 		--config-dir $(CONFIG_FOLDER) \
 		--ledger-dir $(LEDGER_DIR) \
 		--chain-dir $(CHAIN_DIR) \
@@ -93,7 +93,7 @@ dev: ## Compile and run for development with default options
 	cargo run --profile $(BUILD_PROFILE) -- daemon \
 		--ledger-dir $(LEDGER_DIR) \
 		--chain-dir $(CHAIN_DIR) \
-		--peer-address $(AMARU_PEER_ADDRESS) \
+		--peer-address $(PEER_ADDRESS) \
 		--network=$(NETWORK) \
 		--listen-address $(LISTEN_ADDRESS)
 
@@ -125,7 +125,7 @@ coverage-lconv: ## Run test coverage for CI to upload to Codecov
 
 demo: ## Synchronize Amaru until a target epoch $DEMO_TARGET_EPOCH
 	LEDGER_DIR=$(LEDGER_DIR) CHAIN_DIR=$(CHAIN_DIR) \
-		./scripts/demo $(BUILD_PROFILE) $(AMARU_PEER_ADDRESS) $(LISTEN_ADDRESS) $(DEMO_TARGET_EPOCH) $(NETWORK)
+		./scripts/demo $(BUILD_PROFILE) $(PEER_ADDRESS) $(LISTEN_ADDRESS) $(DEMO_TARGET_EPOCH) $(NETWORK)
 
 build-examples: ## Build all examples
 	@for dir in $(wildcard examples/*/.); do \

README.md

@@ -23,7 +23,7 @@ cargo build --release
 on the [preprod](https://book.world.dev.cardano.org/env-preprod.html) network.
 >
 > To run a local peer, refer to [Cardano's developers portal](https://developers.cardano.org/docs/get-started/cardano-node/running-cardano).
-> Make sure your peer listens to port `3001` or adapt the `AMARU_PEER_ADDRESS` environment variable (e.g. `export AMARU_PEER_ADDRESS=127.0.0.1:3002`)
+> Make sure your peer listens to port `3001` or adapt the `PEER_ADDRESS` environment variable (e.g. `export PEER_ADDRESS=127.0.0.1:3002`)
 
 1. Bootstrap the node:
 

crates/amaru-kernel/src/lib.rs

@@ -33,7 +33,6 @@ use pallas_primitives::{
         MintedPostAlonzoTransactionOutput, NativeScript, PseudoDatumOption, RedeemerTag,
         RedeemersValue,
     },
-    PlutusScript,
 };
 use sha3::{Digest as _, Sha3_256};
 use std::{
@@ -47,10 +46,13 @@ use std::{
 };
 
 pub use memoized::*;
-pub use pallas_addresses::{byron::AddrType, Address, Network, StakeAddress, StakePayload};
+pub use pallas_addresses::{
+    byron::AddrType, Address, Network, ShelleyAddress, ShelleyDelegationPart, ShelleyPaymentPart,
+    StakeAddress, StakePayload,
+};
 pub use pallas_codec::{
     minicbor as cbor,
-    utils::{Bytes, CborWrap, KeyValuePairs, NonEmptyKeyValuePairs, Nullable, Set},
+    utils::{Bytes, CborWrap, Int, KeyValuePairs, NonEmptyKeyValuePairs, Nullable, Set},
 };
 pub use pallas_crypto::{
     hash::{Hash, Hasher},
@@ -71,7 +73,8 @@ pub use pallas_primitives::{
         TransactionOutput, Tx, UnitInterval, VKeyWitness, Value, Voter, VotingProcedure,
         VotingProcedures, VrfKeyhash, WitnessSet,
     },
-    AssetName, Constr, DatumHash, MaybeIndefArray, PlutusData,
+    AssetName, BigInt, Constr, DatumHash, MaybeIndefArray, PlutusData, PlutusScript, PolicyId,
+    PositiveCoin,
 };
 pub use pallas_traverse::{ComputeHash, OriginalHash};
 pub use serde_json as json;
@@ -774,7 +777,7 @@ pub fn new_stake_address(network: Network, payload: StakePayload) -> StakeAddres
 // ProposalId
 // ----------------------------------------------------------------------------
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 // TODO: This type shouldn't exist, and `Ord` / `PartialOrd` should be derived in Pallas on
 // 'GovActionId' already.
 pub struct ComparableProposalId {

crates/amaru-kernel/src/memoized/plutus_data.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use crate::{cbor, memoized::blanket_try_from_hex_bytes, Bytes, Hash, Hasher, KeepRaw, PlutusData};
+use pallas_codec::minicbor;
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
 #[serde(try_from = "&str")]
@@ -26,6 +27,16 @@ pub struct MemoizedPlutusData {
 }
 
 impl MemoizedPlutusData {
+    pub fn new(data: PlutusData) -> Result<Self, String> {
+        let mut buf = Vec::new();
+        minicbor::encode(&data, &mut buf).map_err(|_| "failed to encode PlutusData".to_string())?;
+
+        Ok(Self {
+            original_bytes: Bytes::from(buf),
+            data,
+        })
+    }
+
     pub fn original_bytes(&self) -> &[u8] {
         &self.original_bytes
     }

crates/amaru-kernel/src/memoized/transaction_output.rs

@@ -20,10 +20,10 @@ use crate::{
     Value,
 };
 
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, PartialEq)]
 pub struct MemoizedTransactionOutput {
     #[serde(skip)]
-    is_legacy: bool,
+    pub is_legacy: bool,
 
     #[serde(serialize_with = "serialize_address")]
     #[serde(deserialize_with = "deserialize_address")]

crates/amaru-ledger/Cargo.toml

@@ -12,6 +12,10 @@ homepage.workspace = true
 documentation.workspace = true
 rust-version.workspace = true
 
+[features]
+default = []
+test-utils = ["proptest", "slot-arithmetic/test-utils"]
+
 [dependencies]
 hex.workspace = true
 num.workspace = true
@@ -26,9 +30,9 @@ iter-borrow.workspace = true
 progress-bar.workspace = true
 slot-arithmetic.workspace = true
 tracing-json.workspace = true
+proptest = { workspace = true, features = ["std"], optional = true }
 
 [dev-dependencies]
-proptest = { workspace = true, features = [ "std" ] }
 slot-arithmetic = { workspace = true, features = [ "test-utils" ] }
 test-case.workspace = true
 

crates/amaru-ledger/src/store.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 pub mod columns;
-pub mod in_memory;
 
 use crate::summary::Pots;
 use amaru_kernel::MemoizedTransactionOutput;
@@ -118,6 +117,10 @@ pub trait Snapshot: ReadStore {
 }
 
 pub trait Store: ReadStore {
+    type Transaction<'a>: TransactionalContext<'a>
+    where
+        Self: 'a;
+
     /// Construct and save on-disk a snapshot of the store. The epoch number is used when
     /// there's no existing snapshot and, to ensure that snapshots are taken in order.
     ///
@@ -130,7 +133,7 @@ pub trait Store: ReadStore {
     fn next_snapshot(&self, epoch: Epoch) -> Result<(), StoreError>;
 
     /// Create a new transaction context. This is used to perform updates on the store.
-    fn create_transaction(&self) -> impl TransactionalContext<'_>;
+    fn create_transaction(&self) -> Self::Transaction<'_>;
 
     /// Access the tip of the stable store, corresponding to the latest point that was saved.
     fn tip(&self) -> Result<Point, StoreError>;
@@ -166,7 +169,7 @@ pub trait HistoricalStores {
     fn for_epoch(&self, epoch: Epoch) -> Result<impl Snapshot, StoreError>;
 }
 
-#[derive(Debug, PartialEq, Eq, minicbor::Encode, minicbor::Decode)]
+#[derive(Debug, PartialEq, Eq, minicbor::Encode, minicbor::Decode, Clone)]
 pub enum EpochTransitionProgress {
     #[n(0)]
     EpochEnded,
@@ -302,3 +305,23 @@ impl<U, P, A, D, C, PP> Default
         }
     }
 }
+
+impl<U, P, A, D, C, PP> Columns<U, P, A, D, C, PP> {
+    pub fn empty() -> Columns<
+        std::iter::Empty<U>,
+        std::iter::Empty<P>,
+        std::iter::Empty<A>,
+        std::iter::Empty<D>,
+        std::iter::Empty<C>,
+        std::iter::Empty<PP>,
+    > {
+        Columns {
+            utxo: std::iter::empty(),
+            pools: std::iter::empty(),
+            accounts: std::iter::empty(),
+            dreps: std::iter::empty(),
+            cc_members: std::iter::empty(),
+            proposals: std::iter::empty(),
+        }
+    }
+}

crates/amaru-ledger/src/store/columns/accounts.rs

@@ -80,35 +80,22 @@ impl<'a, C> cbor::decode::Decode<'a, C> for Row {
         })
     }
 }
-
-#[cfg(test)]
-pub(crate) mod test {
-    use super::Row;
+#[cfg(any(test, feature = "test-utils"))]
+pub mod tests {
+    use super::*;
     use crate::store::columns::{dreps::tests::any_certificate_pointer, pools::tests::any_pool_id};
-    use amaru_kernel::{prop_cbor_roundtrip, DRep, Hash, Lovelace, StakeCredential};
-    use proptest::{option, prelude::*};
-
-    prop_cbor_roundtrip!(Row, any_row());
+    use amaru_kernel::{prop_cbor_roundtrip, Hash};
+    use proptest::{option, prelude::*, prop_compose};
 
-    prop_compose! {
-        fn any_row()(
-            delegatee in option::of(any_pool_id()),
-            deposit in any::<Lovelace>(),
-            drep in option::of(any_drep()),
-            drep_registered_at in any_certificate_pointer(),
-            rewards in any::<Lovelace>(),
-        ) -> Row {
-            Row {
-                delegatee,
-                deposit,
-                drep: drep.map(|drep| (drep, drep_registered_at)),
-                rewards,
-            }
-        }
+    pub fn any_stake_credential() -> impl Strategy<Value = StakeCredential> {
+        prop_oneof![
+            any::<[u8; 28]>().prop_map(|hash| StakeCredential::AddrKeyhash(Hash::new(hash))),
+            any::<[u8; 28]>().prop_map(|hash| StakeCredential::ScriptHash(Hash::new(hash))),
+        ]
     }
 
     prop_compose! {
-        pub(crate) fn any_drep()(
+        pub fn any_drep()(
             credential in any::<[u8; 28]>(),
             kind in any::<u8>(),
         ) -> DRep {
@@ -120,14 +107,25 @@ pub(crate) mod test {
                 3 => DRep::NoConfidence,
                 _ => unreachable!("% 4")
             }
-
         }
     }
 
-    pub(crate) fn any_stake_credential() -> impl Strategy<Value = StakeCredential> {
-        prop_oneof![
-            any::<[u8; 28]>().prop_map(|hash| StakeCredential::AddrKeyhash(Hash::new(hash))),
-            any::<[u8; 28]>().prop_map(|hash| StakeCredential::ScriptHash(Hash::new(hash))),
-        ]
+    prop_compose! {
+        pub fn any_row()(
+            delegatee in option::of(any_pool_id()),
+            deposit in any::<Lovelace>(),
+            drep in option::of(any_drep()),
+            drep_registered_at in any_certificate_pointer(),
+            rewards in any::<Lovelace>(),
+        ) -> Row {
+            Row {
+                delegatee,
+                deposit,
+                drep: drep.map(|drep| (drep, drep_registered_at)),
+                rewards,
+            }
+        }
     }
+
+    prop_cbor_roundtrip!(Row, any_row());
 }