Struct locutus_runtime::prelude::ContractStore

pub struct ContractStore { /* private fields */ }

Handle contract blob storage on the file system.

Implementations

impl ContractStore

pub fn new(contracts_dir: PathBuf, max_size: i64) -> RuntimeResult<Self>

Arguments

• max_size: max size in bytes of the contracts being cached

pub fn fetch_contract(
    &self,
    key: &ContractKey,
    params: &Parameters<'_>
) -> Option<ContractContainer>

Returns a copy of the contract bytes if available, none otherwise.

Examples found in repository

src/runtime.rs (line 131)

    pub(crate) fn prepare_contract_call(
        &mut self,
        key: &ContractKey,
        parameters: &Parameters,
        req_bytes: usize,
    ) -> RuntimeResult<Instance> {
        let module = if let Some(module) = self.contract_modules.get(key) {
            module
        } else {
            let contract = self
                .contract_store
                .fetch_contract(key, parameters)
                .ok_or_else(|| RuntimeInnerError::ContractNotFound(key.clone()))?;
            let module = match contract {
                ContractContainer::Wasm(WasmAPIVersion::V1(contract_v1)) => {
                    Module::new(&self.wasm_store, contract_v1.code().data())?
                }
            };
            self.contract_modules.insert(key.clone(), module);
            self.contract_modules.get(key).unwrap()
        }
        .clone();
        let instance = self.prepare_instance(&module)?;
        self.set_instance_mem(req_bytes, &instance)?;
        Ok(instance)
    }

pub fn store_contract(
    &mut self,
    contract: ContractContainer
) -> RuntimeResult<()>

Store a copy of the contract in the local store, in case it hasn’t been stored previously.

pub fn get_contract_path(&mut self, key: &ContractKey) -> RuntimeResult<PathBuf>

pub fn code_hash_from_key(&self, key: &ContractKey) -> Option<[u8; 32]>

Examples found in repository

src/contract_store.rs (line 211)

    pub fn get_contract_path(&mut self, key: &ContractKey) -> RuntimeResult<PathBuf> {
        let contract_hash = match key.code_hash() {
            Some(k) => *k,
            None => self.code_hash_from_key(key).ok_or_else(|| {
                tracing::warn!("trying to store partially unspecified contract `{key}`");
                RuntimeInnerError::UnwrapContract
            })?,
        };

        let key_path = bs58::encode(contract_hash)
            .with_alphabet(bs58::Alphabet::BITCOIN)
            .into_string()
            .to_lowercase();
        Ok(self.contracts_dir.join(key_path).with_extension("wasm"))
    }