zcash_protocol: Rename value amounts to `Zatoshis` and `ZatBalance`

components/zcash_protocol/CHANGELOG.md

@@ -14,17 +14,18 @@ The entries below are relative to the `zcash_primitives` crate as of the tag
   moved to this crate:
   - `consensus`
   - `constants`
-  - `zcash_protocol::value` replaces `zcash_primitives::transcation::components::amount`
-- `zcash_protocol::value::Amount::into_u64`
-- `impl TryFrom<u64> for zcash_protocol::value::NonNegativeAmount`
+  - `zcash_protocol::value` replaces `zcash_primitives::transaction::components::amount`
 - Added in `zcash_protocol::value`:
-  - `NonNegativeAmount::into_u64`
-  - `TryFrom<u64> for NonNegativeAmount`
+  - `Zatoshis`
+  - `ZatBalance`
 
 ### Removed
-- The following conversions have been removed from `zcash_protocol::value`, as
-  `zcash_protocol` does not depend on the `orchard` or `sapling-crypto` crates.
-  - `From<NonNegativeAmount> for orchard::NoteValue>`
-  - `TryFrom<orchard::ValueSum> for Amount`
-  - `From<NonNegativeAmount> for sapling::value::NoteValue>`
-  - `TryFrom<sapling::value::NoteValue> for NonNegativeAmount`
+- From `zcash_protocol::value`:
+  - `NonNegativeAmount` (use `Zatoshis` instead.)
+  - `Amount` (use `ZatBalance` instead.)
+  - The following conversions have been removed relative to `zcash_primitives-0.14.0`,
+    as `zcash_protocol` does not depend on the `orchard` or `sapling-crypto` crates.
+    - `From<NonNegativeAmount> for orchard::NoteValue>`
+    - `TryFrom<orchard::ValueSum> for Amount`
+    - `From<NonNegativeAmount> for sapling::value::NoteValue>`
+    - `TryFrom<sapling::value::NoteValue> for NonNegativeAmount`

components/zcash_protocol/src/value.rs

@@ -10,118 +10,118 @@ pub const MAX_MONEY: i64 = 21_000_000 * COIN;
 
 /// A type-safe representation of a Zcash value delta, in zatoshis.
 ///
-/// An Amount can only be constructed from an integer that is within the valid monetary
+/// An ZatBalance can only be constructed from an integer that is within the valid monetary
 /// range of `{-MAX_MONEY..MAX_MONEY}` (where `MAX_MONEY` = 21,000,000 × 10⁸ zatoshis).
 /// However, this range is not preserved as an invariant internally; it is possible to
-/// add two valid Amounts together to obtain an invalid Amount. It is the user's
-/// responsibility to handle the result of serializing potentially-invalid Amounts. In
-/// particular, a [`Transaction`] containing serialized invalid Amounts will be rejected
+/// add two valid ZatBalances together to obtain an invalid ZatBalance. It is the user's
+/// responsibility to handle the result of serializing potentially-invalid ZatBalances. In
+/// particular, a [`Transaction`] containing serialized invalid ZatBalances will be rejected
 /// by the network consensus rules.
 ///
 /// [`Transaction`]: crate::transaction::Transaction
 #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
-pub struct Amount(i64);
+pub struct ZatBalance(i64);
 
-memuse::impl_no_dynamic_usage!(Amount);
+memuse::impl_no_dynamic_usage!(ZatBalance);
 
-impl Amount {
-    /// Returns a zero-valued Amount.
+impl ZatBalance {
+    /// Returns a zero-valued ZatBalance.
     pub const fn zero() -> Self {
-        Amount(0)
+        ZatBalance(0)
     }
 
-    /// Creates a constant Amount from an i64.
+    /// Creates a constant ZatBalance from an i64.
     ///
     /// Panics: if the amount is outside the range `{-MAX_MONEY..MAX_MONEY}`.
     pub const fn const_from_i64(amount: i64) -> Self {
         assert!(-MAX_MONEY <= amount && amount <= MAX_MONEY); // contains is not const
-        Amount(amount)
+        ZatBalance(amount)
     }
 
-    /// Creates a constant Amount from a u64.
+    /// Creates a constant ZatBalance from a u64.
     ///
     /// Panics: if the amount is outside the range `{0..MAX_MONEY}`.
     const fn const_from_u64(amount: u64) -> Self {
         assert!(amount <= (MAX_MONEY as u64)); // contains is not const
-        Amount(amount as i64)
+        ZatBalance(amount as i64)
     }
 
-    /// Creates an Amount from an i64.
+    /// Creates an ZatBalance from an i64.
     ///
     /// Returns an error if the amount is outside the range `{-MAX_MONEY..MAX_MONEY}`.
     pub fn from_i64(amount: i64) -> Result<Self, ()> {
         if (-MAX_MONEY..=MAX_MONEY).contains(&amount) {
-            Ok(Amount(amount))
+            Ok(ZatBalance(amount))
         } else {
             Err(())
         }
     }
 
-    /// Creates a non-negative Amount from an i64.
+    /// Creates a non-negative ZatBalance from an i64.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_nonnegative_i64(amount: i64) -> Result<Self, ()> {
         if (0..=MAX_MONEY).contains(&amount) {
-            Ok(Amount(amount))
+            Ok(ZatBalance(amount))
         } else {
             Err(())
         }
     }
 
-    /// Creates an Amount from a u64.
+    /// Creates an ZatBalance from a u64.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_u64(amount: u64) -> Result<Self, ()> {
         if amount <= MAX_MONEY as u64 {
-            Ok(Amount(amount as i64))
+            Ok(ZatBalance(amount as i64))
         } else {
             Err(())
         }
     }
 
-    /// Reads an Amount from a signed 64-bit little-endian integer.
+    /// Reads an ZatBalance from a signed 64-bit little-endian integer.
     ///
     /// Returns an error if the amount is outside the range `{-MAX_MONEY..MAX_MONEY}`.
     pub fn from_i64_le_bytes(bytes: [u8; 8]) -> Result<Self, ()> {
         let amount = i64::from_le_bytes(bytes);
-        Amount::from_i64(amount)
+        ZatBalance::from_i64(amount)
     }
 
-    /// Reads a non-negative Amount from a signed 64-bit little-endian integer.
+    /// Reads a non-negative ZatBalance from a signed 64-bit little-endian integer.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_nonnegative_i64_le_bytes(bytes: [u8; 8]) -> Result<Self, ()> {
         let amount = i64::from_le_bytes(bytes);
-        Amount::from_nonnegative_i64(amount)
+        ZatBalance::from_nonnegative_i64(amount)
     }
 
-    /// Reads an Amount from an unsigned 64-bit little-endian integer.
+    /// Reads an ZatBalance from an unsigned 64-bit little-endian integer.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_u64_le_bytes(bytes: [u8; 8]) -> Result<Self, ()> {
         let amount = u64::from_le_bytes(bytes);
-        Amount::from_u64(amount)
+        ZatBalance::from_u64(amount)
     }
 
-    /// Returns the Amount encoded as a signed 64-bit little-endian integer.
+    /// Returns the ZatBalance encoded as a signed 64-bit little-endian integer.
     pub fn to_i64_le_bytes(self) -> [u8; 8] {
         self.0.to_le_bytes()
     }
 
-    /// Returns `true` if `self` is positive and `false` if the Amount is zero or
+    /// Returns `true` if `self` is positive and `false` if the ZatBalance is zero or
     /// negative.
     pub const fn is_positive(self) -> bool {
         self.0.is_positive()
     }
 
-    /// Returns `true` if `self` is negative and `false` if the Amount is zero or
+    /// Returns `true` if `self` is negative and `false` if the ZatBalance is zero or
     /// positive.
     pub const fn is_negative(self) -> bool {
         self.0.is_negative()
     }
 
-    pub fn sum<I: IntoIterator<Item = Amount>>(values: I) -> Option<Amount> {
-        let mut result = Amount::zero();
+    pub fn sum<I: IntoIterator<Item = ZatBalance>>(values: I) -> Option<ZatBalance> {
+        let mut result = ZatBalance::zero();
         for value in values {
             result = (result + value)?;
         }
@@ -129,147 +129,147 @@ impl Amount {
     }
 }
 
-impl TryFrom<i64> for Amount {
+impl TryFrom<i64> for ZatBalance {
     type Error = ();
 
     fn try_from(value: i64) -> Result<Self, ()> {
-        Amount::from_i64(value)
+        ZatBalance::from_i64(value)
     }
 }
 
-impl From<Amount> for i64 {
-    fn from(amount: Amount) -> i64 {
+impl From<ZatBalance> for i64 {
+    fn from(amount: ZatBalance) -> i64 {
         amount.0
     }
 }
 
-impl From<&Amount> for i64 {
-    fn from(amount: &Amount) -> i64 {
+impl From<&ZatBalance> for i64 {
+    fn from(amount: &ZatBalance) -> i64 {
         amount.0
     }
 }
 
-impl TryFrom<Amount> for u64 {
+impl TryFrom<ZatBalance> for u64 {
     type Error = ();
 
-    fn try_from(value: Amount) -> Result<Self, Self::Error> {
+    fn try_from(value: ZatBalance) -> Result<Self, Self::Error> {
         value.0.try_into().map_err(|_| ())
     }
 }
 
-impl Add<Amount> for Amount {
-    type Output = Option<Amount>;
+impl Add<ZatBalance> for ZatBalance {
+    type Output = Option<ZatBalance>;
 
-    fn add(self, rhs: Amount) -> Option<Amount> {
-        Amount::from_i64(self.0 + rhs.0).ok()
+    fn add(self, rhs: ZatBalance) -> Option<ZatBalance> {
+        ZatBalance::from_i64(self.0 + rhs.0).ok()
     }
 }
 
-impl Add<Amount> for Option<Amount> {
+impl Add<ZatBalance> for Option<ZatBalance> {
     type Output = Self;
 
-    fn add(self, rhs: Amount) -> Option<Amount> {
+    fn add(self, rhs: ZatBalance) -> Option<ZatBalance> {
         self.and_then(|lhs| lhs + rhs)
     }
 }
 
-impl AddAssign<Amount> for Amount {
-    fn add_assign(&mut self, rhs: Amount) {
+impl AddAssign<ZatBalance> for ZatBalance {
+    fn add_assign(&mut self, rhs: ZatBalance) {
         *self = (*self + rhs).expect("Addition must produce a valid amount value.")
     }
 }
 
-impl Sub<Amount> for Amount {
-    type Output = Option<Amount>;
+impl Sub<ZatBalance> for ZatBalance {
+    type Output = Option<ZatBalance>;
 
-    fn sub(self, rhs: Amount) -> Option<Amount> {
-        Amount::from_i64(self.0 - rhs.0).ok()
+    fn sub(self, rhs: ZatBalance) -> Option<ZatBalance> {
+        ZatBalance::from_i64(self.0 - rhs.0).ok()
     }
 }
 
-impl Sub<Amount> for Option<Amount> {
+impl Sub<ZatBalance> for Option<ZatBalance> {
     type Output = Self;
 
-    fn sub(self, rhs: Amount) -> Option<Amount> {
+    fn sub(self, rhs: ZatBalance) -> Option<ZatBalance> {
         self.and_then(|lhs| lhs - rhs)
     }
 }
 
-impl SubAssign<Amount> for Amount {
-    fn sub_assign(&mut self, rhs: Amount) {
+impl SubAssign<ZatBalance> for ZatBalance {
+    fn sub_assign(&mut self, rhs: ZatBalance) {
         *self = (*self - rhs).expect("Subtraction must produce a valid amount value.")
     }
 }
 
-impl Sum<Amount> for Option<Amount> {
-    fn sum<I: Iterator<Item = Amount>>(iter: I) -> Self {
-        iter.fold(Some(Amount::zero()), |acc, a| acc? + a)
+impl Sum<ZatBalance> for Option<ZatBalance> {
+    fn sum<I: Iterator<Item = ZatBalance>>(iter: I) -> Self {
+        iter.fold(Some(ZatBalance::zero()), |acc, a| acc? + a)
     }
 }
 
-impl<'a> Sum<&'a Amount> for Option<Amount> {
-    fn sum<I: Iterator<Item = &'a Amount>>(iter: I) -> Self {
-        iter.fold(Some(Amount::zero()), |acc, a| acc? + *a)
+impl<'a> Sum<&'a ZatBalance> for Option<ZatBalance> {
+    fn sum<I: Iterator<Item = &'a ZatBalance>>(iter: I) -> Self {
+        iter.fold(Some(ZatBalance::zero()), |acc, a| acc? + *a)
     }
 }
 
-impl Neg for Amount {
+impl Neg for ZatBalance {
     type Output = Self;
 
     fn neg(self) -> Self {
-        Amount(-self.0)
+        ZatBalance(-self.0)
     }
 }
 
-impl Mul<usize> for Amount {
-    type Output = Option<Amount>;
+impl Mul<usize> for ZatBalance {
+    type Output = Option<ZatBalance>;
 
-    fn mul(self, rhs: usize) -> Option<Amount> {
+    fn mul(self, rhs: usize) -> Option<ZatBalance> {
         let rhs: i64 = rhs.try_into().ok()?;
         self.0
             .checked_mul(rhs)
-            .and_then(|i| Amount::try_from(i).ok())
+            .and_then(|i| ZatBalance::try_from(i).ok())
     }
 }
 
 /// A type-safe representation of some nonnegative amount of Zcash.
 ///
-/// A NonNegativeAmount can only be constructed from an integer that is within the valid monetary
+/// A Zatoshis can only be constructed from an integer that is within the valid monetary
 /// range of `{0..MAX_MONEY}` (where `MAX_MONEY` = 21,000,000 × 10⁸ zatoshis).
 #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
-pub struct NonNegativeAmount(Amount);
+pub struct Zatoshis(ZatBalance);
 
-impl NonNegativeAmount {
-    /// Returns the identity `NonNegativeAmount`
-    pub const ZERO: Self = NonNegativeAmount(Amount(0));
+impl Zatoshis {
+    /// Returns the identity `Zatoshis`
+    pub const ZERO: Self = Zatoshis(ZatBalance(0));
 
-    /// Returns this NonNegativeAmount as a u64.
+    /// Returns this Zatoshis as a u64.
     pub fn into_u64(self) -> u64 {
         self.0.try_into().unwrap()
     }
 
-    /// Creates a NonNegativeAmount from a u64.
+    /// Creates a Zatoshis from a u64.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_u64(amount: u64) -> Result<Self, ()> {
-        Amount::from_u64(amount).map(NonNegativeAmount)
+        ZatBalance::from_u64(amount).map(Zatoshis)
     }
 
-    /// Creates a constant NonNegativeAmount from a u64.
+    /// Creates a constant Zatoshis from a u64.
     ///
     /// Panics: if the amount is outside the range `{-MAX_MONEY..MAX_MONEY}`.
     pub const fn const_from_u64(amount: u64) -> Self {
-        NonNegativeAmount(Amount::const_from_u64(amount))
+        Zatoshis(ZatBalance::const_from_u64(amount))
     }
 
-    /// Creates a NonNegativeAmount from an i64.
+    /// Creates a Zatoshis from an i64.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_nonnegative_i64(amount: i64) -> Result<Self, ()> {
-        Amount::from_nonnegative_i64(amount).map(NonNegativeAmount)
+        ZatBalance::from_nonnegative_i64(amount).map(Zatoshis)
     }
 
-    /// Reads an NonNegativeAmount from an unsigned 64-bit little-endian integer.
+    /// Reads an Zatoshis from an unsigned 64-bit little-endian integer.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
     pub fn from_u64_le_bytes(bytes: [u8; 8]) -> Result<Self, ()> {
@@ -277,7 +277,7 @@ impl NonNegativeAmount {
         Self::from_u64(amount)
     }
 
-    /// Reads a NonNegativeAmount from a signed integer represented as a two's
+    /// Reads a Zatoshis from a signed integer represented as a two's
     /// complement 64-bit little-endian value.
     ///
     /// Returns an error if the amount is outside the range `{0..MAX_MONEY}`.
@@ -286,110 +286,110 @@ impl NonNegativeAmount {
         Self::from_nonnegative_i64(amount)
     }
 
-    /// Returns this NonNegativeAmount encoded as a signed two's complement 64-bit
+    /// Returns this Zatoshis encoded as a signed two's complement 64-bit
     /// little-endian value.
     pub fn to_i64_le_bytes(self) -> [u8; 8] {
         self.0.to_i64_le_bytes()
     }
 
-    /// Returns whether or not this `NonNegativeAmount` is the zero value.
+    /// Returns whether or not this `Zatoshis` is the zero value.
     pub fn is_zero(&self) -> bool {
-        self == &NonNegativeAmount::ZERO
+        self == &Zatoshis::ZERO
     }
 
-    /// Returns whether or not this `NonNegativeAmount` is positive.
+    /// Returns whether or not this `Zatoshis` is positive.
     pub fn is_positive(&self) -> bool {
-        self > &NonNegativeAmount::ZERO
+        self > &Zatoshis::ZERO
     }
 }
 
-impl From<NonNegativeAmount> for Amount {
-    fn from(n: NonNegativeAmount) -> Self {
+impl From<Zatoshis> for ZatBalance {
+    fn from(n: Zatoshis) -> Self {
         n.0
     }
 }
 
-impl From<&NonNegativeAmount> for Amount {
-    fn from(n: &NonNegativeAmount) -> Self {
+impl From<&Zatoshis> for ZatBalance {
+    fn from(n: &Zatoshis) -> Self {
         n.0
     }
 }
 
-impl From<NonNegativeAmount> for u64 {
-    fn from(n: NonNegativeAmount) -> Self {
+impl From<Zatoshis> for u64 {
+    fn from(n: Zatoshis) -> Self {
         n.into_u64()
     }
 }
 
-impl TryFrom<u64> for NonNegativeAmount {
+impl TryFrom<u64> for Zatoshis {
     type Error = ();
 
     fn try_from(value: u64) -> Result<Self, Self::Error> {
-        NonNegativeAmount::from_u64(value)
+        Zatoshis::from_u64(value)
     }
 }
 
-impl TryFrom<Amount> for NonNegativeAmount {
+impl TryFrom<ZatBalance> for Zatoshis {
     type Error = ();
 
-    fn try_from(value: Amount) -> Result<Self, Self::Error> {
+    fn try_from(value: ZatBalance) -> Result<Self, Self::Error> {
         if value.is_negative() {
             Err(())
         } else {
-            Ok(NonNegativeAmount(value))
+            Ok(Zatoshis(value))
         }
     }
 }
 
-impl Add<NonNegativeAmount> for NonNegativeAmount {
-    type Output = Option<NonNegativeAmount>;
+impl Add<Zatoshis> for Zatoshis {
+    type Output = Option<Zatoshis>;
 
-    fn add(self, rhs: NonNegativeAmount) -> Option<NonNegativeAmount> {
-        (self.0 + rhs.0).map(NonNegativeAmount)
+    fn add(self, rhs: Zatoshis) -> Option<Zatoshis> {
+        (self.0 + rhs.0).map(Zatoshis)
     }
 }
 
-impl Add<NonNegativeAmount> for Option<NonNegativeAmount> {
+impl Add<Zatoshis> for Option<Zatoshis> {
     type Output = Self;
 
-    fn add(self, rhs: NonNegativeAmount) -> Option<NonNegativeAmount> {
+    fn add(self, rhs: Zatoshis) -> Option<Zatoshis> {
         self.and_then(|lhs| lhs + rhs)
     }
 }
 
-impl Sub<NonNegativeAmount> for NonNegativeAmount {
-    type Output = Option<NonNegativeAmount>;
+impl Sub<Zatoshis> for Zatoshis {
+    type Output = Option<Zatoshis>;
 
-    fn sub(self, rhs: NonNegativeAmount) -> Option<NonNegativeAmount> {
-        (self.0 - rhs.0).and_then(|amt| NonNegativeAmount::try_from(amt).ok())
+    fn sub(self, rhs: Zatoshis) -> Option<Zatoshis> {
+        (self.0 - rhs.0).and_then(|amt| Zatoshis::try_from(amt).ok())
     }
 }
 
-impl Sub<NonNegativeAmount> for Option<NonNegativeAmount> {
+impl Sub<Zatoshis> for Option<Zatoshis> {
     type Output = Self;
 
-    fn sub(self, rhs: NonNegativeAmount) -> Option<NonNegativeAmount> {
+    fn sub(self, rhs: Zatoshis) -> Option<Zatoshis> {
         self.and_then(|lhs| lhs - rhs)
     }
 }
 
-impl Mul<usize> for NonNegativeAmount {
+impl Mul<usize> for Zatoshis {
     type Output = Option<Self>;
 
-    fn mul(self, rhs: usize) -> Option<NonNegativeAmount> {
-        (self.0 * rhs).and_then(|v| NonNegativeAmount::try_from(v).ok())
+    fn mul(self, rhs: usize) -> Option<Zatoshis> {
+        (self.0 * rhs).and_then(|v| Zatoshis::try_from(v).ok())
     }
 }
 
-impl Sum<NonNegativeAmount> for Option<NonNegativeAmount> {
-    fn sum<I: Iterator<Item = NonNegativeAmount>>(iter: I) -> Self {
-        iter.fold(Some(NonNegativeAmount::ZERO), |acc, a| acc? + a)
+impl Sum<Zatoshis> for Option<Zatoshis> {
+    fn sum<I: Iterator<Item = Zatoshis>>(iter: I) -> Self {
+        iter.fold(Some(Zatoshis::ZERO), |acc, a| acc? + a)
     }
 }
 
-impl<'a> Sum<&'a NonNegativeAmount> for Option<NonNegativeAmount> {
-    fn sum<I: Iterator<Item = &'a NonNegativeAmount>>(iter: I) -> Self {
-        iter.fold(Some(NonNegativeAmount::ZERO), |acc, a| acc? + *a)
+impl<'a> Sum<&'a Zatoshis> for Option<Zatoshis> {
+    fn sum<I: Iterator<Item = &'a Zatoshis>>(iter: I) -> Self {
+        iter.fold(Some(Zatoshis::ZERO), |acc, a| acc? + *a)
     }
 }
 
@@ -409,12 +409,12 @@ impl std::fmt::Display for BalanceError {
             BalanceError::Overflow => {
                 write!(
                     f,
-                    "Amount addition resulted in a value outside the valid range."
+                    "ZatBalance addition resulted in a value outside the valid range."
                 )
             }
             BalanceError::Underflow => write!(
                 f,
-                "Amount subtraction resulted in a value outside the valid range."
+                "ZatBalance subtraction resulted in a value outside the valid range."
             ),
         }
     }
@@ -430,102 +430,105 @@ impl From<Infallible> for BalanceError {
 pub mod testing {
     use proptest::prelude::prop_compose;
 
-    use super::{Amount, NonNegativeAmount, MAX_MONEY};
+    use super::{ZatBalance, Zatoshis, MAX_MONEY};
 
     prop_compose! {
-        pub fn arb_amount()(amt in -MAX_MONEY..MAX_MONEY) -> Amount {
-            Amount::from_i64(amt).unwrap()
+        pub fn arb_zat_balance()(amt in -MAX_MONEY..MAX_MONEY) -> ZatBalance {
+            ZatBalance::from_i64(amt).unwrap()
         }
     }
 
     prop_compose! {
-        pub fn arb_nonnegative_amount()(amt in 0i64..MAX_MONEY) -> NonNegativeAmount {
-            NonNegativeAmount::from_u64(amt as u64).unwrap()
+        pub fn arb_positive_zat_balance()(amt in 1i64..MAX_MONEY) -> ZatBalance {
+            ZatBalance::from_i64(amt).unwrap()
         }
     }
 
     prop_compose! {
-        pub fn arb_positive_amount()(amt in 1i64..MAX_MONEY) -> Amount {
-            Amount::from_i64(amt).unwrap()
+        pub fn arb_zatoshis()(amt in 0i64..MAX_MONEY) -> Zatoshis {
+            Zatoshis::from_u64(amt as u64).unwrap()
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{Amount, MAX_MONEY};
+    use super::{ZatBalance, MAX_MONEY};
 
     #[test]
     fn amount_in_range() {
         let zero = b"\x00\x00\x00\x00\x00\x00\x00\x00";
-        assert_eq!(Amount::from_u64_le_bytes(*zero).unwrap(), Amount(0));
+        assert_eq!(ZatBalance::from_u64_le_bytes(*zero).unwrap(), ZatBalance(0));
         assert_eq!(
-            Amount::from_nonnegative_i64_le_bytes(*zero).unwrap(),
-            Amount(0)
+            ZatBalance::from_nonnegative_i64_le_bytes(*zero).unwrap(),
+            ZatBalance(0)
         );
-        assert_eq!(Amount::from_i64_le_bytes(*zero).unwrap(), Amount(0));
+        assert_eq!(ZatBalance::from_i64_le_bytes(*zero).unwrap(), ZatBalance(0));
 
         let neg_one = b"\xff\xff\xff\xff\xff\xff\xff\xff";
-        assert!(Amount::from_u64_le_bytes(*neg_one).is_err());
-        assert!(Amount::from_nonnegative_i64_le_bytes(*neg_one).is_err());
-        assert_eq!(Amount::from_i64_le_bytes(*neg_one).unwrap(), Amount(-1));
+        assert!(ZatBalance::from_u64_le_bytes(*neg_one).is_err());
+        assert!(ZatBalance::from_nonnegative_i64_le_bytes(*neg_one).is_err());
+        assert_eq!(
+            ZatBalance::from_i64_le_bytes(*neg_one).unwrap(),
+            ZatBalance(-1)
+        );
 
         let max_money = b"\x00\x40\x07\x5a\xf0\x75\x07\x00";
         assert_eq!(
-            Amount::from_u64_le_bytes(*max_money).unwrap(),
-            Amount(MAX_MONEY)
+            ZatBalance::from_u64_le_bytes(*max_money).unwrap(),
+            ZatBalance(MAX_MONEY)
         );
         assert_eq!(
-            Amount::from_nonnegative_i64_le_bytes(*max_money).unwrap(),
-            Amount(MAX_MONEY)
+            ZatBalance::from_nonnegative_i64_le_bytes(*max_money).unwrap(),
+            ZatBalance(MAX_MONEY)
         );
         assert_eq!(
-            Amount::from_i64_le_bytes(*max_money).unwrap(),
-            Amount(MAX_MONEY)
+            ZatBalance::from_i64_le_bytes(*max_money).unwrap(),
+            ZatBalance(MAX_MONEY)
         );
 
         let max_money_p1 = b"\x01\x40\x07\x5a\xf0\x75\x07\x00";
-        assert!(Amount::from_u64_le_bytes(*max_money_p1).is_err());
-        assert!(Amount::from_nonnegative_i64_le_bytes(*max_money_p1).is_err());
-        assert!(Amount::from_i64_le_bytes(*max_money_p1).is_err());
+        assert!(ZatBalance::from_u64_le_bytes(*max_money_p1).is_err());
+        assert!(ZatBalance::from_nonnegative_i64_le_bytes(*max_money_p1).is_err());
+        assert!(ZatBalance::from_i64_le_bytes(*max_money_p1).is_err());
 
         let neg_max_money = b"\x00\xc0\xf8\xa5\x0f\x8a\xf8\xff";
-        assert!(Amount::from_u64_le_bytes(*neg_max_money).is_err());
-        assert!(Amount::from_nonnegative_i64_le_bytes(*neg_max_money).is_err());
+        assert!(ZatBalance::from_u64_le_bytes(*neg_max_money).is_err());
+        assert!(ZatBalance::from_nonnegative_i64_le_bytes(*neg_max_money).is_err());
         assert_eq!(
-            Amount::from_i64_le_bytes(*neg_max_money).unwrap(),
-            Amount(-MAX_MONEY)
+            ZatBalance::from_i64_le_bytes(*neg_max_money).unwrap(),
+            ZatBalance(-MAX_MONEY)
         );
 
         let neg_max_money_m1 = b"\xff\xbf\xf8\xa5\x0f\x8a\xf8\xff";
-        assert!(Amount::from_u64_le_bytes(*neg_max_money_m1).is_err());
-        assert!(Amount::from_nonnegative_i64_le_bytes(*neg_max_money_m1).is_err());
-        assert!(Amount::from_i64_le_bytes(*neg_max_money_m1).is_err());
+        assert!(ZatBalance::from_u64_le_bytes(*neg_max_money_m1).is_err());
+        assert!(ZatBalance::from_nonnegative_i64_le_bytes(*neg_max_money_m1).is_err());
+        assert!(ZatBalance::from_i64_le_bytes(*neg_max_money_m1).is_err());
     }
 
     #[test]
     fn add_overflow() {
-        let v = Amount(MAX_MONEY);
-        assert_eq!(v + Amount(1), None)
+        let v = ZatBalance(MAX_MONEY);
+        assert_eq!(v + ZatBalance(1), None)
     }
 
     #[test]
     #[should_panic]
     fn add_assign_panics_on_overflow() {
-        let mut a = Amount(MAX_MONEY);
-        a += Amount(1);
+        let mut a = ZatBalance(MAX_MONEY);
+        a += ZatBalance(1);
     }
 
     #[test]
     fn sub_underflow() {
-        let v = Amount(-MAX_MONEY);
-        assert_eq!(v - Amount(1), None)
+        let v = ZatBalance(-MAX_MONEY);
+        assert_eq!(v - ZatBalance(1), None)
     }
 
     #[test]
     #[should_panic]
     fn sub_assign_panics_on_underflow() {
-        let mut a = Amount(-MAX_MONEY);
-        a -= Amount(1);
+        let mut a = ZatBalance(-MAX_MONEY);
+        a -= ZatBalance(1);
     }
 }

zcash_primitives/src/transaction/components.rs

@@ -1,6 +1,17 @@
 //! Structs representing the components within Zcash transactions.
+pub mod amount {
+    pub use zcash_protocol::value::{
+        BalanceError, ZatBalance as Amount, Zatoshis as NonNegativeAmount, COIN,
+    };
 
-pub use zcash_protocol::value as amount;
+    #[cfg(feature = "test-dependencies")]
+    pub mod testing {
+        pub use zcash_protocol::value::testing::{
+            arb_positive_zat_balance as arb_positive_amount, arb_zat_balance as arb_amount,
+            arb_zatoshis as arb_nonnegative_amount,
+        };
+    }
+}
 pub mod orchard;
 pub mod sapling;
 pub mod sprout;