fix(lib): reducing code size by merging modules

bucket/ddc_bucket/account/store.rs

@@ -9,12 +9,12 @@ use crate::ddc_bucket::{
 };
 use crate::ddc_bucket::currency::CurrencyConverter;
 use crate::ddc_bucket::flow::Flow;
-use ink_storage::traits::{SpreadAllocate, SpreadLayout, StorageLayout};
+use ink_storage::traits::{SpreadAllocate, SpreadLayout};
 use ink_prelude::vec::Vec;
 use super::entity::Account;
 
 #[derive(Default, SpreadLayout, SpreadAllocate)]
-#[cfg_attr(feature = "std", derive(StorageLayout, Debug))]
+#[cfg_attr(feature = "std", derive(ink_storage::traits::StorageLayout, Debug))]
 pub struct AccountStore(
     pub Mapping<AccountId, Account>,
     pub CurrencyConverter,

bucket/ddc_bucket/bucket/entity.rs

@@ -1,6 +1,7 @@
 //! The data structure of Buckets.
 
 use ink_prelude::vec::Vec;
+use ink_prelude::string::String;
 use ink_storage::traits::{SpreadAllocate, PackedAllocate, PackedLayout, SpreadLayout};
 use scale::{Decode, Encode};
 use ink_primitives::Key;
@@ -10,10 +11,10 @@ use crate::ddc_bucket::{
 };
 use crate::ddc_bucket::flow::Flow;
 use crate::ddc_bucket::node::entity::Resource;
-use crate::ddc_bucket::params::store::Params;
+
 
 pub type BucketId = u32;
-pub type BucketParams = Params;
+pub type BucketParams = String;
 
 #[derive(Clone, PartialEq, Encode, Decode, SpreadAllocate, SpreadLayout, PackedLayout)]
 #[cfg_attr(feature = "std", derive(Debug, scale_info::TypeInfo))]
@@ -24,6 +25,7 @@ pub struct Bucket {
     pub resource_reserved: Resource,
     pub public_availability: bool,
     pub resource_consumption_cap: Resource, 
+    pub bucket_params: BucketParams
 }
 
 // https://use.ink/3.x/ink-vs-solidity#nested-mappings--custom--advanced-structures
@@ -58,6 +60,8 @@ pub struct BucketStatus {
     pub rent_covered_until_ms: u64,
 }
 
+pub const BUCKET_PARAMS_MAX_LEN: usize = 100_000;
+
 impl Bucket {
     pub fn only_owner(&self, caller: AccountId) -> Result<()> {
         if self.owner_id == caller { Ok(()) } else { Err(OnlyOwner) }
@@ -78,6 +82,15 @@ impl Bucket {
     pub fn change_owner(&mut self, owner_id: AccountId) {
         self.owner_id = owner_id;
     }
+
+    pub fn set_params(&mut self, bucket_params: BucketParams) -> Result<()> {
+        if bucket_params.len() > BUCKET_PARAMS_MAX_LEN {
+            return Err(ParamsSizeExceedsLimit);
+        }
+        self.bucket_params = bucket_params;
+        Ok(())
+    }
+
 }
 
 impl From<Bucket> for BucketInStatus {

bucket/ddc_bucket/bucket/messages.rs

@@ -3,7 +3,7 @@
 use ink_lang::codegen::{EmitEvent, StaticEnv};
 use ink_prelude::vec::Vec;
 
-use crate::ddc_bucket::{AccountId, BucketAllocated, BucketCreated, BucketSettlePayment, BucketAvailabilityUpdated, DdcBucket, Result};
+use crate::ddc_bucket::{AccountId, BucketAllocated, BucketCreated, BucketSettlePayment, BucketAvailabilityUpdated, BucketParamsSet, DdcBucket, Result};
 use crate::ddc_bucket::cluster::entity::{Cluster, ClusterId};
 use crate::ddc_bucket::node::entity::Resource;
 
@@ -13,25 +13,24 @@ impl DdcBucket {
     pub fn message_bucket_create(&mut self, bucket_params: BucketParams, cluster_id: ClusterId, owner_id: Option<AccountId>) -> Result<BucketId> {
         let owner_id = owner_id.unwrap_or(Self::env().caller());
         self.accounts.create_if_not_exist(owner_id);
-        let bucket_id = self.buckets.create(owner_id, cluster_id);
-        let params_id = self.bucket_params.create(bucket_params)?;
-        assert_eq!(bucket_id, params_id);
+        let bucket_id = self.buckets.create(owner_id, cluster_id, bucket_params);
         Self::env().emit_event(BucketCreated { bucket_id, owner_id });
         Ok(bucket_id)
     }
 
     pub fn message_bucket_change_owner(&mut self, bucket_id: BucketId, owner_id: AccountId) -> Result<()> {
         let caller = Self::env().caller();
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
         bucket.only_owner(caller)?;
         bucket.change_owner(owner_id);
+        self.buckets.update(bucket_id, &bucket)?;
         Ok(())
     }
 
     pub fn message_bucket_alloc_into_cluster(&mut self, bucket_id: BucketId, resource: Resource) -> Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
         let mut cluster = self.clusters.get(bucket.cluster_id)?;
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
 
         cluster.take_resource(resource)?;
         self.clusters.update(bucket.cluster_id, &cluster)?;
@@ -42,32 +41,36 @@ impl DdcBucket {
         let now_ms = Self::env().block_timestamp();
 
         self.accounts.increase_flow(now_ms, rent, &mut bucket.flow)?;
+        self.buckets.update(bucket_id, &bucket)?;
 
         Self::env().emit_event(BucketAllocated { bucket_id, cluster_id: bucket.cluster_id, resource });
         Ok(())
     }
 
     pub fn message_bucket_settle_payment(&mut self, bucket_id: BucketId) -> Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
 
         let now_ms = Self::env().block_timestamp();
         let cash = self.accounts.settle_flow(now_ms, &mut bucket.flow)?;
 
         let mut cluster = self.clusters.get(bucket.cluster_id)?;
         cluster.revenues.increase(cash);
         self.clusters.update(bucket.cluster_id, &cluster)?;
+        self.buckets.update(bucket_id, &bucket)?;
 
         Self::env().emit_event(BucketSettlePayment { bucket_id, cluster_id: bucket.cluster_id });
         Ok(())
     }
 
 
-    pub fn message_bucket_change_params(&mut self, bucket_id: BucketId, params: BucketParams) -> Result<()> {
+    pub fn message_bucket_change_params(&mut self, bucket_id: BucketId, bucket_params: BucketParams) -> Result<()> {
         let caller = Self::env().caller();
-        let bucket = self.buckets.get(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
         bucket.only_owner(caller)?;
-
-        Self::impl_change_params(&mut self.bucket_params, bucket_id, params)
+        bucket.set_params(bucket_params.clone())?;
+        self.buckets.update(bucket_id, &bucket)?;
+        Self::env().emit_event(BucketParamsSet { bucket_id, bucket_params });
+        Ok(())
     }
 
     pub fn message_bucket_get(&self, bucket_id: BucketId) -> Result<BucketStatus> {
@@ -78,7 +81,7 @@ impl DdcBucket {
     pub fn message_bucket_list(&self, offset: u32, limit: u32, filter_owner_id: Option<AccountId>) -> (Vec<BucketStatus>, u32) {
         let mut bucket_statuses = Vec::with_capacity(limit as usize);
         for bucket_id in offset..offset + limit {
-            let bucket = match self.buckets.0.get(bucket_id as usize) {
+            let bucket = match self.buckets.buckets.get(bucket_id) {
                 None => break, // No more buckets, stop.
                 Some(bucket) => bucket,
             };
@@ -95,89 +98,104 @@ impl DdcBucket {
                     bucket_statuses.push(status),
             };
         }
-        (bucket_statuses, self.buckets.0.len().try_into().unwrap())
+        (bucket_statuses, self.buckets.next_bucket_id)
     }
 
     pub fn message_bucket_list_for_account(&self, owner_id: AccountId) -> Vec<Bucket> {
-        self.buckets.0
-            .iter()
-            .filter(|bucket| bucket.owner_id == owner_id)
-            .cloned()
-            .collect()
+        let mut result : Vec<Bucket>  = Vec::new();
+
+        for bucket_id in 0..self.buckets.next_bucket_id {
+            let bucket = self.buckets.get(bucket_id).unwrap();
+
+            if bucket.owner_id == owner_id {
+                result.push(bucket);
+            };
+        }
+
+        result
     }
 
     pub fn bucket_calculate_status(&self, bucket_id: BucketId, bucket: Bucket) -> Result<BucketStatus> {
-        let mut writer_ids = self.buckets_perms.get_bucket_readers(bucket_id);
+        let mut writer_ids = self.buckets.get_bucket_readers(bucket_id);
         writer_ids.push(bucket.owner_id);
         let rent_covered_until_ms = self.accounts.flow_covered_until(&bucket.flow)?;
-        let params = self.bucket_params.get(bucket_id)?.clone();
-        let reader_ids = self.buckets_perms.get_bucket_readers(bucket_id);
-        Ok(BucketStatus { bucket_id, bucket: bucket.into(), params, writer_ids, reader_ids, rent_covered_until_ms })
+        let reader_ids = self.buckets.get_bucket_readers(bucket_id);
+        let bucket_params = bucket.bucket_params.clone();
+
+        Ok(BucketStatus { bucket_id, params: bucket_params, bucket: bucket.into(), writer_ids, reader_ids, rent_covered_until_ms })
     }
 
     pub fn message_bucket_set_resource_cap(&mut self, bucket_id: BucketId, new_resource_cap: Resource) ->  Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
         bucket.set_cap(new_resource_cap);
+        self.buckets.update(bucket_id, &bucket)?;
+
         Ok(())
     }
 
     pub fn message_bucket_set_availability(&mut self, bucket_id: BucketId, public_availability: bool) -> Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let mut bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
         bucket.set_availability(public_availability);
 
+        self.buckets.update(bucket_id, &bucket)?;
+
         Self::env().emit_event(BucketAvailabilityUpdated { bucket_id, public_availability });
         Ok(())
     }
 
     pub fn message_get_bucket_writers(&mut self, bucket_id: BucketId) -> Result<Vec<AccountId>> {
-        let writers = self.buckets_perms.get_bucket_writers(bucket_id);
+        let writers = self.buckets.get_bucket_writers(bucket_id);
         Ok(writers)
     }
 
     pub fn message_grant_writer_permission(&mut self, bucket_id: BucketId, writer: AccountId) -> Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
-        self.buckets_perms.grant_writer_permission(bucket_id, writer).unwrap();
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
+        self.buckets.grant_writer_permission(bucket_id, writer).unwrap();
+
         Ok(())
     }
 
     pub fn message_revoke_writer_permission(&mut self, bucket_id: BucketId, writer: AccountId) -> Result<()> { 
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
-        self.buckets_perms.revoke_writer_permission(bucket_id, writer).unwrap();
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
+        self.buckets.revoke_writer_permission(bucket_id, writer).unwrap();
+
         Ok(())
     }
 
     pub fn message_get_bucket_readers(&mut self, bucket_id: BucketId) -> Result<Vec<AccountId>> {
-        let readers = self.buckets_perms.get_bucket_readers(bucket_id);
+        let readers = self.buckets.get_bucket_readers(bucket_id);
         Ok(readers)
     }
 
     pub fn message_grant_reader_permission(&mut self, bucket_id: BucketId, reader: AccountId) -> Result<()> {
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
-        self.buckets_perms.grant_reader_permission(bucket_id, reader).unwrap();
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
+        self.buckets.grant_reader_permission(bucket_id, reader).unwrap();
+
         Ok(())
     }
 
     pub fn message_revoke_reader_permission(&mut self, bucket_id: BucketId, reader: AccountId) -> Result<()> { 
-        let bucket = self.buckets.get_mut(bucket_id)?;
+        let bucket = self.buckets.get(bucket_id)?;
         let cluster = self.clusters.get(bucket.cluster_id)?;
 
-        Self::only_owner_or_cluster_manager(bucket, &cluster)?;
-        self.buckets_perms.revoke_reader_permission(bucket_id, reader).unwrap();
+        Self::only_owner_or_cluster_manager(&bucket, &cluster)?;
+        self.buckets.revoke_reader_permission(bucket_id, reader).unwrap();
+
         Ok(())
     }