Feature/resource movements static analysis

radix-common/src/crypto/public_key_hash.rs

@@ -21,6 +21,14 @@ pub trait IsPublicKeyHash: Copy {
     fn into_enum(self) -> PublicKeyHash;
 }
 
+impl<H: IsPublicKeyHash> HasPublicKeyHash for H {
+    type TypedPublicKeyHash = Self;
+
+    fn get_hash(&self) -> Self::TypedPublicKeyHash {
+        *self
+    }
+}
+
 pub fn hash_public_key_bytes<T: AsRef<[u8]>>(key_bytes: T) -> [u8; NodeId::RID_LENGTH] {
     hash(key_bytes).lower_bytes()
 }

radix-common/src/data/manifest/model/manifest_expression.rs

@@ -1,21 +1,161 @@
+use crate::internal_prelude::*;
 #[cfg(feature = "fuzzing")]
 use arbitrary::Arbitrary;
-use sbor::rust::convert::TryFrom;
-#[cfg(not(feature = "alloc"))]
-use sbor::rust::fmt;
-use sbor::rust::vec::Vec;
-use sbor::*;
 
 use crate::data::manifest::*;
 use crate::*;
 
 #[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ManifestExpression {
+    /// Can be encoded into [`BucketBatch`]
     EntireWorktop,
+    /// Can be encoded into [`ProofBatch`]
     EntireAuthZone,
 }
 
+//========
+// Alternative Representations
+//========
+
+#[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum BucketBatch {
+    ManifestBuckets(Vec<ManifestBucket>),
+    EntireWorktop,
+}
+
+impl BucketBatch {
+    pub fn from_buckets(buckets: impl IntoIterator<Item = ManifestBucket>) -> Self {
+        Self::ManifestBuckets(buckets.into_iter().collect())
+    }
+}
+
+impl<E: sbor::Encoder<ManifestCustomValueKind>> sbor::Encode<ManifestCustomValueKind, E>
+    for BucketBatch
+{
+    #[inline]
+    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), sbor::EncodeError> {
+        match self {
+            BucketBatch::ManifestBuckets(buckets) => buckets.encode_value_kind(encoder),
+            BucketBatch::EntireWorktop => {
+                ManifestExpression::EntireWorktop.encode_value_kind(encoder)
+            }
+        }
+    }
+
+    #[inline]
+    fn encode_body(&self, encoder: &mut E) -> Result<(), sbor::EncodeError> {
+        match self {
+            BucketBatch::ManifestBuckets(buckets) => buckets.encode_body(encoder),
+            BucketBatch::EntireWorktop => ManifestExpression::EntireWorktop.encode_body(encoder),
+        }
+    }
+}
+
+impl<D: sbor::Decoder<ManifestCustomValueKind>> sbor::Decode<ManifestCustomValueKind, D>
+    for BucketBatch
+{
+    fn decode_body_with_value_kind(
+        decoder: &mut D,
+        value_kind: sbor::ValueKind<ManifestCustomValueKind>,
+    ) -> Result<Self, sbor::DecodeError> {
+        Ok(match value_kind {
+            ValueKind::Array => Self::ManifestBuckets(
+                Vec::<ManifestBucket>::decode_body_with_value_kind(decoder, value_kind)?,
+            ),
+            ValueKind::Custom(_) => {
+                let expression =
+                    ManifestExpression::decode_body_with_value_kind(decoder, value_kind)?;
+                if !matches!(expression, ManifestExpression::EntireWorktop) {
+                    return Err(sbor::DecodeError::InvalidCustomValue);
+                }
+                Self::EntireWorktop
+            }
+            _ => {
+                return Err(sbor::DecodeError::UnexpectedValueKind {
+                    expected: ManifestValueKind::Array.as_u8(),
+                    actual: value_kind.as_u8(),
+                });
+            }
+        })
+    }
+}
+
+impl sbor::Describe<ScryptoCustomTypeKind> for BucketBatch {
+    const TYPE_ID: sbor::RustTypeId = Vec::<ManifestBucket>::TYPE_ID;
+
+    fn type_data() -> sbor::TypeData<ScryptoCustomTypeKind, sbor::RustTypeId> {
+        Vec::<ManifestBucket>::type_data()
+    }
+}
+
+#[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ProofBatch {
+    ManifestProofs(Vec<ManifestProof>),
+    EntireAuthZone,
+}
+
+impl<E: sbor::Encoder<ManifestCustomValueKind>> sbor::Encode<ManifestCustomValueKind, E>
+    for ProofBatch
+{
+    #[inline]
+    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), sbor::EncodeError> {
+        match self {
+            ProofBatch::ManifestProofs(proofs) => proofs.encode_value_kind(encoder),
+            ProofBatch::EntireAuthZone => {
+                ManifestExpression::EntireAuthZone.encode_value_kind(encoder)
+            }
+        }
+    }
+
+    #[inline]
+    fn encode_body(&self, encoder: &mut E) -> Result<(), sbor::EncodeError> {
+        match self {
+            ProofBatch::ManifestProofs(proofs) => proofs.encode_body(encoder),
+            ProofBatch::EntireAuthZone => ManifestExpression::EntireAuthZone.encode_body(encoder),
+        }
+    }
+}
+
+impl<D: sbor::Decoder<ManifestCustomValueKind>> sbor::Decode<ManifestCustomValueKind, D>
+    for ProofBatch
+{
+    fn decode_body_with_value_kind(
+        decoder: &mut D,
+        value_kind: sbor::ValueKind<ManifestCustomValueKind>,
+    ) -> Result<Self, sbor::DecodeError> {
+        Ok(match value_kind {
+            ValueKind::Array => Self::ManifestProofs(
+                Vec::<ManifestProof>::decode_body_with_value_kind(decoder, value_kind)?,
+            ),
+            ValueKind::Custom(_) => {
+                let expression =
+                    ManifestExpression::decode_body_with_value_kind(decoder, value_kind)?;
+                if !matches!(expression, ManifestExpression::EntireAuthZone) {
+                    return Err(sbor::DecodeError::InvalidCustomValue);
+                }
+                Self::EntireAuthZone
+            }
+            _ => {
+                return Err(sbor::DecodeError::UnexpectedValueKind {
+                    expected: ManifestValueKind::Array.as_u8(),
+                    actual: value_kind.as_u8(),
+                });
+            }
+        })
+    }
+}
+
+impl sbor::Describe<ScryptoCustomTypeKind> for ProofBatch {
+    const TYPE_ID: sbor::RustTypeId = Vec::<ManifestProof>::TYPE_ID;
+
+    fn type_data() -> sbor::TypeData<ScryptoCustomTypeKind, sbor::RustTypeId> {
+        Vec::<ManifestProof>::type_data()
+    }
+}
+
 //========
 // error
 //========

radix-common/src/math/bnum_integer.rs

@@ -366,6 +366,15 @@ macro_rules! op_impl {
                     }
                 }
 
+                impl SaturatingAdd for $t
+                {
+                    type Output = $t;
+
+                    fn saturating_add(self, other: Self) -> Self::Output {
+                        Self(self.0.saturating_add(other.0))
+                    }
+                }
+
                 impl CheckedSub for $t
                 {
                     type Output = $t;

radix-common/src/math/decimal.rs

@@ -74,6 +74,10 @@ impl Decimal {
     pub const TEN: Self = Self(I192::from_digits([10_u64.pow(Decimal::SCALE + 1), 0, 0]));
     pub const ONE_HUNDRED: Self = Self(I192::from_digits([7766279631452241920, 0x5, 0]));
 
+    pub const fn from_attos(attos: I192) -> Self {
+        Self(attos)
+    }
+
     /// Returns `Decimal` of 0.
     pub const fn zero() -> Self {
         Self::ZERO
@@ -364,6 +368,15 @@ impl CheckedAdd<Decimal> for Decimal {
     }
 }
 
+impl SaturatingAdd<Decimal> for Decimal {
+    type Output = Self;
+
+    #[inline]
+    fn saturating_add(self, other: Self) -> Self::Output {
+        Self(self.0.saturating_add(other.0))
+    }
+}
+
 impl CheckedSub<Decimal> for Decimal {
     type Output = Self;
 

radix-common/src/math/traits.rs

@@ -6,6 +6,14 @@ pub trait CheckedAdd<Rhs = Self> {
         Self: Sized;
 }
 
+pub trait SaturatingAdd<Rhs = Self> {
+    type Output;
+
+    fn saturating_add(self, other: Rhs) -> Self::Output
+    where
+        Self: Sized;
+}
+
 pub trait CheckedSub<Rhs = Self> {
     type Output;
 

radix-common/src/types/entity_type.rs

@@ -176,6 +176,15 @@ impl EntityType {
         matches!(self, EntityType::GlobalPackage)
     }
 
+    pub const fn is_global_account(&self) -> bool {
+        matches!(
+            self,
+            EntityType::GlobalAccount
+                | EntityType::GlobalPreallocatedSecp256k1Account
+                | EntityType::GlobalPreallocatedEd25519Account
+        )
+    }
+
     pub const fn is_global_consensus_manager(&self) -> bool {
         matches!(self, EntityType::GlobalConsensusManager)
     }

radix-common/src/types/node_and_substate.rs

@@ -72,6 +72,10 @@ impl NodeId {
         matches!(self.entity_type(), Some(t) if t.is_global_component())
     }
 
+    pub const fn is_global_account(&self) -> bool {
+        matches!(self.entity_type(), Some(t) if t.is_global_account())
+    }
+
     pub const fn is_global_package(&self) -> bool {
         matches!(self.entity_type(), Some(t) if t.is_global_package())
     }

radix-common/src/types/non_fungible_global_id.rs

@@ -181,12 +181,12 @@ pub trait FromPublicKey: Sized {
 }
 
 impl FromPublicKey for NonFungibleGlobalId {
-    /// Prefer using the `signature` function or the `signature_proof()` method.
+    /// Prefer using the `signature(public_key)` or `public_key.signature_proof()`.
     fn from_public_key<P: HasPublicKeyHash>(public_key: &P) -> Self {
         Self::from_public_key_hash(public_key.get_hash())
     }
 
-    /// Prefer using the `signature` function or the `signature_proof()` method.
+    /// Prefer using the `signature(public_key_hash)` function or the `public_key_hash.signature_proof()` method.
     fn from_public_key_hash<P: IsPublicKeyHash>(public_key_hash: P) -> Self {
         match public_key_hash.into_enum() {
             PublicKeyHash::Secp256k1(public_key_hash) => NonFungibleGlobalId::new(

radix-engine-interface/src/blueprints/account/invocations.rs

@@ -135,7 +135,7 @@ pub struct AccountDepositBatchInput {
 
 #[derive(Debug, Eq, PartialEq, ManifestSbor)]
 pub struct AccountDepositBatchManifestInput {
-    pub buckets: Vec<ManifestBucket>,
+    pub buckets: BucketBatch,
 }
 
 pub type AccountDepositBatchOutput = ();
@@ -301,7 +301,7 @@ pub struct AccountTryDepositBatchOrRefundInput {
 
 #[derive(Debug, Eq, PartialEq, ManifestSbor)]
 pub struct AccountTryDepositBatchOrRefundManifestInput {
-    pub buckets: Vec<ManifestBucket>,
+    pub buckets: BucketBatch,
     pub authorized_depositor_badge: Option<ResourceOrNonFungible>,
 }
 
@@ -341,7 +341,7 @@ pub struct AccountTryDepositBatchOrAbortInput {
 
 #[derive(Debug, Eq, PartialEq, ManifestSbor)]
 pub struct AccountTryDepositBatchOrAbortManifestInput {
-    pub buckets: Vec<ManifestBucket>,
+    pub buckets: BucketBatch,
     pub authorized_depositor_badge: Option<ResourceOrNonFungible>,
 }
 

radix-engine-interface/src/blueprints/pool/multi_resource_pool/invocations.rs

@@ -33,7 +33,7 @@ define_invocation! {
     },
     output: type (Bucket, Vec<Bucket>),
     manifest_input: struct {
-        buckets: Vec<ManifestBucket>
+        buckets: BucketBatch
     }
 }
 

radix-engine-tests/tests/application/mod.rs

@@ -9,6 +9,7 @@ mod local_component;
 mod metering;
 mod preview;
 mod stake_reconciliation;
+mod static_resource_movements_visitor;
 mod storage;
 mod stored_external_component;
 mod stored_local_component;