refactor: implement Deref/DerefMut for BitcoinAmount

Author: Rajil1213

crates/primitives/src/l1.rs

@@ -1,7 +1,7 @@
 use std::io::{self, ErrorKind};
 use std::io::{Read, Write};
 use std::iter::Sum;
-use std::ops::Add;
+use std::ops::{Add, Deref, DerefMut};
 use std::str::FromStr;
 
 use anyhow::{anyhow, Context};
@@ -10,7 +10,7 @@ use bitcoin::address::NetworkUnchecked;
 use bitcoin::consensus::serialize;
 use bitcoin::hashes::{sha256d, Hash};
 use bitcoin::key::TapTweak;
-use bitcoin::{Address, AddressType, Block, Network, OutPoint, XOnlyPublicKey};
+use bitcoin::{Address, AddressType, Amount, Block, Network, OutPoint, XOnlyPublicKey};
 use borsh::{BorshDeserialize, BorshSerialize};
 use reth_primitives::revm_primitives::FixedBytes;
 use serde::{Deserialize, Serialize};
@@ -292,75 +292,75 @@ impl BorshDeserialize for BitcoinAddress {
     }
 }
 
-/// A wrapper for bitcoin amount in sats similar to the implementation in [`bitcoin::Amount`].
+/// A wrapper for [`bitcoin::Amount`].
 ///
 /// NOTE: This wrapper has been created so that we can implement `Borsh*` traits on it.
-#[derive(
-    Debug,
-    Clone,
-    Copy,
-    Serialize,
-    Deserialize,
-    Eq,
-    PartialEq,
-    BorshSerialize,
-    BorshDeserialize,
-    Arbitrary,
-)]
-pub struct BitcoinAmount(u64);
-
-impl BitcoinAmount {
-    // The zero amount.
-    pub const ZERO: BitcoinAmount = Self(0);
-    /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: BitcoinAmount = Self::from_int_btc(21_000_000);
-    /// The minimum value of an amount.
-    pub const MIN: BitcoinAmount = Self::ZERO;
-    /// The maximum value of an amount.
-    pub const MAX: BitcoinAmount = Self(u64::MAX);
-    /// The number of bytes that an amount contributes to the size of a transaction.
-    pub const SIZE: usize = 8; // Serialized length of a u64.
-                               // The number of sats in 1 bitcoin.
-    pub const SATS_FACTOR: u64 = 100_000_000;
-
-    /// Get the number of sats in this [`BitcoinAmount`].
-    pub fn to_sat(&self) -> u64 {
-        self.0
-    }
-
-    /// Create a [`BitcoinAmount`] with sats precision and the given number of sats.
-    pub const fn from_sat(value: u64) -> Self {
-        Self(value)
-    }
-
-    /// Convert from a value expressing integer values of bitcoins to a [`BitcoinAmount`]
-    /// in const context.
-    ///
-    /// ## Panics
-    ///
-    /// The function panics if the argument multiplied by the number of sats
-    /// per bitcoin overflows a u64 type.
-    pub const fn from_int_btc(btc: u64) -> Self {
-        match btc.checked_mul(Self::SATS_FACTOR) {
-            Some(amount) => Self::from_sat(amount),
-            None => {
-                panic!("number of sats greater than u64::MAX");
-            }
-        }
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+pub struct BitcoinAmount(Amount);
+
+impl From<Amount> for BitcoinAmount {
+    fn from(value: Amount) -> Self {
+        BitcoinAmount(value)
+    }
+}
+
+impl Deref for BitcoinAmount {
+    type Target = Amount;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for BitcoinAmount {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl BorshSerialize for BitcoinAmount {
+    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+        let sats = self.0.to_sat();
+
+        borsh::BorshSerialize::serialize(&sats, writer)
+    }
+}
+
+impl BorshDeserialize for BitcoinAmount {
+    fn deserialize(buf: &mut &[u8]) -> io::Result<Self> {
+        let sats = borsh::BorshDeserialize::deserialize(buf)?;
+
+        Ok(BitcoinAmount(Amount::from_sat(sats)))
+    }
+
+    fn deserialize_reader<R: Read>(reader: &mut R) -> io::Result<Self> {
+        let sats = borsh::BorshDeserialize::deserialize_reader(reader)?;
+
+        Ok(BitcoinAmount(Amount::from_sat(sats)))
+    }
+}
+
+impl<'a> Arbitrary<'a> for BitcoinAmount {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        // Generate a random u64 value and convert it to Amount
+        let sats: u64 = u.arbitrary()?;
+        Ok(BitcoinAmount(Amount::from_sat(sats)))
     }
 }
 
 impl Add for BitcoinAmount {
     type Output = BitcoinAmount;
 
     fn add(self, rhs: Self) -> Self::Output {
-        Self::from_sat(self.to_sat() + rhs.to_sat())
+        BitcoinAmount(self.0 + rhs.0)
     }
 }
 
 impl Sum for BitcoinAmount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        Self::from_sat(iter.map(|amt| amt.to_sat()).sum())
+        let total_amt = iter.fold(Amount::ZERO, |acc, amt| acc + amt.0);
+
+        BitcoinAmount(total_amt)
     }
 }
 
@@ -416,10 +416,7 @@ impl XOnlyPk {
 
 #[cfg(test)]
 mod tests {
-    use super::{
-        BitcoinAddress, BitcoinAmount, BorshDeserialize, BorshSerialize, OutPoint, OutputRef,
-        XOnlyPk,
-    };
+    use super::{BitcoinAddress, BorshDeserialize, BorshSerialize, OutPoint, OutputRef, XOnlyPk};
     use arbitrary::{Arbitrary, Unstructured};
     use bitcoin::{
         hashes::Hash,
@@ -558,14 +555,6 @@ mod tests {
         );
     }
 
-    #[test]
-    #[should_panic(expected = "number of sats greater than u64::MAX")]
-    fn bitcoinamount_should_handle_sats_exceeding_u64_max() {
-        let bitcoins: u64 = u64::MAX / BitcoinAmount::SATS_FACTOR + 1;
-
-        BitcoinAmount::from_int_btc(bitcoins);
-    }
-
     fn get_taproot_address(
         secp: &Secp256k1<All>,
         network: Network,

crates/rpc/api/src/lib.rs

@@ -4,12 +4,12 @@ use alpen_express_rpc_types::{
     types::{BlockHeader, ClientStatus, DepositEntry, ExecUpdate, L1Status},
     L2BlockId,
 };
+use alpen_express_state::bridge_duties::BridgeDuties;
 use alpen_express_state::bridge_state::OperatorIdx;
-use alpen_express_state::{bridge_duties::BridgeDuties, bridge_ops::WithdrawalBatch};
 use express_bridge_txm::{DepositInfo, ReimbursementRequest};
 
 use bitcoin::secp256k1::schnorr::Signature;
-use bitcoin::{OutPoint, Transaction, Txid};
+use bitcoin::{Transaction, Txid};
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;

crates/state/src/bridge_ops.rs

@@ -5,8 +5,6 @@ use serde::{Deserialize, Serialize};
 
 use alpen_express_primitives::l1::{BitcoinAmount, XOnlyPk};
 
-pub const WITHDRAWAL_DENOMINATION: BitcoinAmount = BitcoinAmount::from_int_btc(10);
-
 /// Describes an intent to withdraw that hasn't been dispatched yet.
 #[derive(Clone, Debug, Eq, PartialEq, BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
 pub struct WithdrawalIntent {