substrate - 在 Substrate 中，有没有办法在另一个自定义模块中使用存储和功能？

Question

我已经看过关于创建单个 Substrate 运行时模块的 crate 的 Substrate 教程 here为了重用该功能，但我想知道一个自定义模块是否有办法从另一个自定义模块访问存储或功能？

这些方面的东西:

/// In ModuleA

    pub type IndexType = u64;

    decl_storage! {
        trait Store for Module<T: Trait> as ModuleA {
                pub MyIndexCount get(my_index_count): Option<IndexType>;
        }
    }

然后在 ModuleB 内部 - 我需要做什么才能使用/包含 ModuleA 的功能，我该如何称呼它？

/// In ModuleB

    decl_module! {
    pub struct Module<T: Trait> for enum Call where origin: T::Origin {
        fn deposit_event<T>() = default;

        pub fn edit_index(origin) -> Result {
            let sender = ensure_signed(origin)?;

            // --->>>> I want to read some storage from ModuleA whilst inside ModuleB
            let c: IndexType = ReadStorageFromModuleA >>> my_index_count().ok_or("Storage Read Error: cannot get index")?;

            // change storage in ModuleA from ModuleB
            WriteToStorageInModuleA <MyIndexCount<T>>::put(&c + 1);

            Ok(())
            }
        }
    }    

Answer 1

如果您正在构建一个直接依赖于另一个模块 (module1) 的模块 (module2)，则必须在 module2 的 trait 定义中继承 module1 的 trait:

pub trait Trait: module1::Trait {
    ...
}

访问 公众 在module2中存储来自module1的项目，你需要做以下事情:

导入适当的存储特征以访问存储 API:StorageValue , StorageMap等...

通过module1的存储类型访问公共(public)存储

<module1::Something<T>>::get()

<module1::Something<T>>::put()

等等...

访问其他 公众 模块 2 中模块 1 的函数，您需要使用 Module类型:

<module1::Module<T>>::public_function();

这是两个以这种方式交互的模块的简单示例:

模块1.rs

Note that all the things in this module are marked public (pub)

use support::{decl_module, decl_storage, StorageValue};

pub trait Trait: system::Trait {}

decl_storage! {
    trait Store for Module<T: Trait> as TemplateModule {
        pub Something: u32;
    }
}

decl_module! {
    pub struct Module<T: Trait> for enum Call where origin: T::Origin {
    }
}

impl<T: Trait> Module<T> {
    pub fn get_value() -> u32 {
        <Something<T>>::get()
    }
}

模块2.rs

use support::{decl_module, decl_event, StorageValue, dispatch::Result};
use system::ensure_signed;

use crate::module1;

pub trait Trait: module1::Trait {
    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
}

decl_module! {
    /// The module declaration.
    pub struct Module<T: Trait> for enum Call where origin: T::Origin {
        fn deposit_event<T>() = default;

        pub fn get_value_directly(origin) -> Result {
            let who = ensure_signed(origin)?;
            let value = <module1::Something<T>>::get();
            Self::deposit_event(RawEvent::ValueIs(value, who));
            Ok(())
        }

        pub fn set_value_directly(origin, value: u32) -> Result {
            let _ = ensure_signed(origin)?;
            <module1::Something<T>>::put(value);
            Ok(())
        }

        pub fn get_value_public_function(origin) -> Result {
            let who = ensure_signed(origin)?;
            let value = <module1::Module<T>>::get_value();
            Self::deposit_event(RawEvent::ValueIs(value, who));
            Ok(())
        }
    }
}

decl_event!(
    pub enum Event<T> where <T as system::Trait>::AccountId {
        ValueIs(u32, AccountId),
    }
);