Merge branch 'main' into refactor-p2p-config

Author: cong-or

src/chain-libs/chain-impl-mockchain/src/account.rs

@@ -8,7 +8,9 @@ use chain_core::{
 };
 use chain_crypto::{Ed25519, PublicKey, Signature};
 
-pub use account::{DelegationRatio, DelegationType, LedgerError, SpendingCounter};
+pub use account::{
+    DelegationRatio, DelegationType, LedgerError, SpendingCounter, SpendingCounterIncreasing,
+};
 
 pub type AccountAlg = Ed25519;
 

src/chain-libs/chain-impl-mockchain/src/accounting/account/spending.rs

@@ -6,14 +6,16 @@ pub enum Error {
         expected: SpendingCounter,
         actual: SpendingCounter,
     },
+    #[error("Invalid lane value during the SpendingCountersIncreasingInitialization, expected: {0}, got: {1}")]
+    InvalidLaneValue(usize, usize),
     #[error("Invalid lane: {0} or counter: {1}, expected lane < (1 << LANES_BITS), counter < (1 << UNLANES_BITS)")]
     InvalidLaneOrCounter(usize, u32),
 }
 
 /// Simple strategy to spend from multiple increasing counters
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SpendingCounterIncreasing {
-    nexts: Vec<SpendingCounter>,
+    nexts: [SpendingCounter; Self::LANES],
 }
 
 // SpendingCounterIncreasing has extra invariants (e.g. nexts has 8 elements, each belongs to a different lane), so a derived implementation is not suitable
@@ -33,25 +35,23 @@ impl SpendingCounterIncreasing {
         x
     }
 
-    pub fn new_from_counters(set: Vec<SpendingCounter>) -> Option<Self> {
-        if set.len() == Self::LANES {
-            for (i, i_set_value) in set.iter().enumerate() {
-                if i_set_value.lane() != i {
-                    return None;
-                }
+    pub fn new_from_counters(
+        nexts: [SpendingCounter; SpendingCounterIncreasing::LANES],
+    ) -> Result<Self, Error> {
+        for (i, i_set_value) in nexts.iter().enumerate() {
+            if i_set_value.lane() != i {
+                return Err(Error::InvalidLaneValue(i, i_set_value.lane()));
             }
-            Some(SpendingCounterIncreasing { nexts: set })
-        } else {
-            None
         }
+        Ok(SpendingCounterIncreasing { nexts })
     }
 
     pub fn get_valid_counter(&self) -> SpendingCounter {
         self.nexts[0]
     }
 
-    pub fn get_valid_counters(&self) -> Vec<SpendingCounter> {
-        self.nexts.clone()
+    pub fn get_valid_counters(&self) -> [SpendingCounter; Self::LANES] {
+        self.nexts
     }
 
     /// try to match the lane of the counter in argument, if it doesn't match
@@ -85,10 +85,16 @@ impl std::fmt::Display for SpendingCounterIncreasing {
 
 impl Default for SpendingCounterIncreasing {
     fn default() -> Self {
-        let mut nexts = Vec::new();
-        for i in 0..Self::LANES {
-            nexts.push(SpendingCounter::new(i, 0).unwrap());
-        }
+        let nexts = [
+            SpendingCounter::new(0, 0).unwrap(),
+            SpendingCounter::new(1, 0).unwrap(),
+            SpendingCounter::new(2, 0).unwrap(),
+            SpendingCounter::new(3, 0).unwrap(),
+            SpendingCounter::new(4, 0).unwrap(),
+            SpendingCounter::new(5, 0).unwrap(),
+            SpendingCounter::new(6, 0).unwrap(),
+            SpendingCounter::new(7, 0).unwrap(),
+        ];
         SpendingCounterIncreasing { nexts }
     }
 }
@@ -107,7 +113,7 @@ impl Default for SpendingCounterIncreasing {
     any(test, feature = "property-test-api"),
     derive(test_strategy::Arbitrary)
 )]
-pub struct SpendingCounter(pub(crate) u32);
+pub struct SpendingCounter(u32);
 
 impl SpendingCounter {
     // on 32 bits: 0x1fff_ffff;
@@ -254,25 +260,32 @@ mod tests {
 
     #[test]
     pub fn spending_counters_duplication() {
-        let counters = vec![SpendingCounter::zero(), SpendingCounter::zero()];
-        assert!(SpendingCounterIncreasing::new_from_counters(counters).is_none());
+        let counters = [
+            SpendingCounter::zero(),
+            SpendingCounter::zero(),
+            SpendingCounter::new(2, 0).unwrap(),
+            SpendingCounter::new(3, 0).unwrap(),
+            SpendingCounter::new(4, 0).unwrap(),
+            SpendingCounter::new(5, 0).unwrap(),
+            SpendingCounter::new(6, 0).unwrap(),
+            SpendingCounter::new(7, 0).unwrap(),
+        ];
+        assert!(SpendingCounterIncreasing::new_from_counters(counters).is_err());
     }
 
     #[test]
     pub fn spending_counters_incorrect_order() {
-        let counters = vec![
+        let counters = [
             SpendingCounter::new(1, 0).unwrap(),
             SpendingCounter::new(0, 0).unwrap(),
+            SpendingCounter::new(2, 0).unwrap(),
+            SpendingCounter::new(3, 0).unwrap(),
+            SpendingCounter::new(4, 0).unwrap(),
+            SpendingCounter::new(5, 0).unwrap(),
+            SpendingCounter::new(6, 0).unwrap(),
+            SpendingCounter::new(7, 0).unwrap(),
         ];
-        assert!(SpendingCounterIncreasing::new_from_counters(counters).is_none());
-    }
-
-    #[test]
-    pub fn spending_counters_too_many_sub_counters() {
-        let counters = std::iter::from_fn(|| Some(SpendingCounter::zero()))
-            .take(SpendingCounterIncreasing::LANES + 1)
-            .collect();
-        assert!(SpendingCounterIncreasing::new_from_counters(counters).is_none());
+        assert!(SpendingCounterIncreasing::new_from_counters(counters).is_err());
     }
 
     #[quickcheck_macros::quickcheck]
@@ -315,8 +328,8 @@ mod tests {
                     any::<SpendingCounter>()
                         .prop_map(|counter| Some(Self::new_from_counter(counter)))
                         .boxed(),
-                    any::<Vec<SpendingCounter>>()
-                        .prop_map(Self::new_from_counters)
+                    any::<[SpendingCounter; SpendingCounterIncreasing::LANES]>()
+                        .prop_map(|counters| Self::new_from_counters(counters).ok())
                         .boxed(),
                 ]
                 .prop_filter_map("must be valid spending counter set", |i| i)

src/chain-libs/chain-impl-mockchain/src/ledger/recovery.rs

@@ -38,8 +38,7 @@
 use super::pots;
 use super::{Entry, EntryOwned};
 use crate::accounting::account::{
-    AccountState, DelegationRatio, DelegationType, LastRewards, SpendingCounter,
-    SpendingCounterIncreasing,
+    AccountState, DelegationRatio, DelegationType, LastRewards, SpendingCounterIncreasing,
 };
 use crate::certificate::{
     PoolId, PoolRegistration, Proposal, Proposals, UpdateProposal, UpdateProposalId, UpdateVoterId,
@@ -161,19 +160,18 @@ fn pack_spending_strategy<W: std::io::Write>(
 fn unpack_spending_strategy(
     codec: &mut Codec<&[u8]>,
 ) -> Result<SpendingCounterIncreasing, ReadError> {
-    let mut counters = Vec::new();
-    for _ in 0..SpendingCounterIncreasing::LANES {
-        let counter = SpendingCounter(codec.get_be_u32()?);
-        counters.push(counter);
-    }
-    let got_length = counters.len();
-    SpendingCounterIncreasing::new_from_counters(counters).ok_or_else(|| {
-        ReadError::InvalidData(format!(
-            "wrong numbers of lanes, expecting {} but got {}",
-            SpendingCounterIncreasing::LANES,
-            got_length,
-        ))
-    })
+    let counters = [
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+        codec.get_be_u32()?.into(),
+    ];
+    SpendingCounterIncreasing::new_from_counters(counters)
+        .map_err(|e| ReadError::InvalidData(e.to_string()))
 }
 
 #[cfg(feature = "evm")]

src/chain-wallet-libs/bindings/wallet-core/src/c/mod.rs

@@ -8,7 +8,9 @@ pub mod time;
 pub mod vote;
 
 use crate::{Error, Proposal, Result, Wallet};
-use chain_impl_mockchain::{fragment::Fragment, value::Value, vote::Choice};
+use chain_impl_mockchain::{
+    account::SpendingCounterIncreasing, fragment::Fragment, value::Value, vote::Choice,
+};
 use std::convert::TryInto;
 
 use thiserror::Error;
@@ -166,13 +168,11 @@ pub unsafe fn wallet_spending_counters(
     let wallet = non_null!(wallet);
     let spending_counters_out = non_null_mut!(spending_counters_ptr_out);
 
-    let counters = wallet.spending_counter().into_boxed_slice();
-    let len = counters.len();
+    let counters: Box<[u32]> = wallet.spending_counter().as_slice().into();
 
     let raw_ptr = Box::into_raw(counters);
 
     spending_counters_out.data = raw_ptr as *mut u32;
-    spending_counters_out.len = len;
 
     Result::success()
 }
@@ -215,7 +215,6 @@ pub unsafe fn wallet_total_value(wallet: WalletPtr, total_out: *mut u64) -> Resu
 #[repr(C)]
 pub struct SpendingCounters {
     pub data: *mut u32,
-    pub len: usize,
 }
 
 /// update the wallet account state
@@ -245,7 +244,13 @@ pub unsafe fn wallet_set_state(wallet: WalletPtr, value: u64, nonces: SpendingCo
 
     let value = Value(value);
 
-    let nonces = std::slice::from_raw_parts_mut(nonces.data, nonces.len).to_vec();
+    let nonces = match std::slice::from_raw_parts_mut(nonces.data, SpendingCounterIncreasing::LANES)
+        .try_into()
+        .map_err(|_e| Error::invalid_spending_counters())
+    {
+        Ok(nonces) => nonces,
+        Err(e) => return e.into(),
+    };
 
     match wallet.set_state(value, nonces) {
         Ok(_) => Result::success(),
@@ -423,9 +428,9 @@ pub unsafe fn wallet_delete_proposal(proposal: ProposalPtr) {
 /// This function is safe as long as the structure returned by this library is not modified.
 /// This function should only be called with a structure returned by this library.
 pub unsafe fn spending_counters_delete(spending_counters: SpendingCounters) {
-    let SpendingCounters { data, len } = spending_counters;
+    let SpendingCounters { data } = spending_counters;
     if !data.is_null() {
-        let data = std::slice::from_raw_parts_mut(data, len);
+        let data = std::slice::from_raw_parts_mut(data, SpendingCounterIncreasing::LANES);
         let data = Box::from_raw(data as *mut [u32]);
         std::mem::drop(data);
     }

src/chain-wallet-libs/bindings/wallet-core/src/wallet.rs

@@ -2,7 +2,7 @@ use crate::{Error, Proposal};
 use chain_core::property::Serialize as _;
 use chain_crypto::SecretKey;
 use chain_impl_mockchain::{
-    account::SpendingCounter,
+    account::SpendingCounterIncreasing,
     block::BlockDate,
     certificate::Certificate,
     fragment::{Fragment, FragmentId},
@@ -62,12 +62,18 @@ impl Wallet {
 
     /// get the current spending counter
     ///
-    pub fn spending_counter(&self) -> Vec<u32> {
-        self.account
-            .spending_counter()
-            .into_iter()
-            .map(SpendingCounter::into)
-            .collect()
+    pub fn spending_counter(&self) -> [u32; SpendingCounterIncreasing::LANES] {
+        let spending_counters = self.account.spending_counter();
+        [
+            spending_counters[0].into(),
+            spending_counters[1].into(),
+            spending_counters[2].into(),
+            spending_counters[3].into(),
+            spending_counters[4].into(),
+            spending_counters[5].into(),
+            spending_counters[6].into(),
+            spending_counters[7].into(),
+        ]
     }
 
     /// get the total value in the wallet
@@ -92,11 +98,24 @@ impl Wallet {
     /// before doing any transactions, otherwise future transactions may fail
     /// to be accepted by the blockchain nodes because of an invalid witness
     /// signature.
-    pub fn set_state(&mut self, value: Value, counters: Vec<u32>) -> Result<(), Error> {
+    pub fn set_state(
+        &mut self,
+        value: Value,
+        counters: [u32; SpendingCounterIncreasing::LANES],
+    ) -> Result<(), Error> {
         self.account
             .set_state(
                 value,
-                counters.into_iter().map(SpendingCounter::from).collect(),
+                [
+                    counters[0].into(),
+                    counters[1].into(),
+                    counters[2].into(),
+                    counters[3].into(),
+                    counters[4].into(),
+                    counters[5].into(),
+                    counters[6].into(),
+                    counters[7].into(),
+                ],
             )
             .map_err(|_| Error::invalid_spending_counters())
     }

src/chain-wallet-libs/wallet/src/account.rs

@@ -2,7 +2,7 @@ use super::transaction::AccountWitnessBuilder;
 use crate::scheme::{on_tx_input_and_witnesses, on_tx_output};
 use crate::states::States;
 use chain_crypto::{Ed25519, Ed25519Extended, PublicKey, SecretKey};
-use chain_impl_mockchain::accounting::account::SpendingCounterIncreasing;
+use chain_impl_mockchain::accounting::account::{spending, SpendingCounterIncreasing};
 use chain_impl_mockchain::{
     account::SpendingCounter,
     fragment::{Fragment, FragmentId},
@@ -37,10 +37,10 @@ pub enum Error {
     NotEnoughFunds { current: Value, needed: Value },
     #[error("invalid lane for spending counter")]
     InvalidLane,
-    #[error("malformed spending counters")]
-    MalformedSpendingCounters,
     #[error("spending counter does not match current state")]
     NonMonotonicSpendingCounter,
+    #[error(transparent)]
+    SpendingCounters(#[from] spending::Error),
 }
 
 pub enum EitherAccount {
@@ -109,16 +109,19 @@ impl Wallet {
     ///
     /// TODO: change to a constructor/initializator?, or just make it so it resets the state
     ///
-    pub fn set_state(&mut self, value: Value, counters: Vec<SpendingCounter>) -> Result<(), Error> {
-        let counters = SpendingCounterIncreasing::new_from_counters(counters)
-            .ok_or(Error::MalformedSpendingCounters)?;
+    pub fn set_state(
+        &mut self,
+        value: Value,
+        counters: [SpendingCounter; SpendingCounterIncreasing::LANES],
+    ) -> Result<(), Error> {
+        let counters = SpendingCounterIncreasing::new_from_counters(counters)?;
 
         self.state = States::new(FragmentId::zero_hash(), State { value, counters });
 
         Ok(())
     }
 
-    pub fn spending_counter(&self) -> Vec<SpendingCounter> {
+    pub fn spending_counter(&self) -> [SpendingCounter; SpendingCounterIncreasing::LANES] {
         self.state
             .last_state()
             .state()

src/chain-wallet-libs/wallet/tests/account.rs

@@ -4,7 +4,6 @@ use self::utils::State;
 use chain_crypto::SecretKey;
 use chain_impl_mockchain::{
     account::SpendingCounter,
-    accounting::account::SpendingCounterIncreasing,
     certificate::VoteCast,
     fragment::Fragment,
     value::Value,
@@ -30,9 +29,16 @@ fn update_state_overrides_old() {
     account
         .set_state(
             Value(110),
-            (0..SpendingCounterIncreasing::LANES)
-                .map(|lane| SpendingCounter::new(lane, 1).unwrap())
-                .collect(),
+            [
+                SpendingCounter::new(0, 1).unwrap(),
+                SpendingCounter::new(1, 1).unwrap(),
+                SpendingCounter::new(2, 1).unwrap(),
+                SpendingCounter::new(3, 1).unwrap(),
+                SpendingCounter::new(4, 1).unwrap(),
+                SpendingCounter::new(5, 1).unwrap(),
+                SpendingCounter::new(6, 1).unwrap(),
+                SpendingCounter::new(7, 1).unwrap(),
+            ],
         )
         .unwrap();