corevm 0.1.28

The JAM CoreVM Service, a container service for running regular software on JAM.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use alloc::borrow::Cow;
use codec::Encode;
use corevm_engine::AccumulateOps;
use corevm_host::StorageKey;
use jam_pvm_common::{
	accumulate::{bless, get_foreign_storage, remove_storage, set_storage, transfer, zombify},
	service_info_field, ApiError,
};
use jam_types::{Balance, Memo, ServiceId, UnsignedGas};

/// An implementation of `AccumulateOps` that forwards all host-calls to JAM.
pub struct JamAccumulateOps;

impl AccumulateOps for JamAccumulateOps {
	type Error = ApiError;

	fn get(&self, service: ServiceId, key: &StorageKey) -> Option<Cow<'_, [u8]>> {
		key.using_encoded(|key| get_foreign_storage(service, key)).map(Cow::Owned)
	}

	fn set(&mut self, key: StorageKey, value: Cow<'_, [u8]>) -> Result<(), Self::Error> {
		key.using_encoded(|key| set_storage(key, value.as_ref()))?;
		Ok(())
	}

	fn remove(&mut self, key: &StorageKey) -> bool {
		key.using_encoded(|key| remove_storage(key).is_some())
	}

	fn min_memo_gas(&self, service: ServiceId) -> Option<UnsignedGas> {
		service_info_field!(u64::from(service), min_memo_gas)
	}

	fn transfer(
		&self,
		destination: ServiceId,
		amount: Balance,
		gas_limit: UnsignedGas,
		memo: &Memo,
	) -> Result<(), Self::Error> {
		transfer(destination, amount, gas_limit, memo)
	}

	fn bless<'a>(
		&mut self,
		manager: ServiceId,
		assigner: ServiceId,
		designator: ServiceId,
		registrar: ServiceId,
		always_acc: impl IntoIterator<Item = &'a (ServiceId, UnsignedGas)>,
	) {
		bless(manager, assigner, designator, registrar, always_acc);
	}

	fn zombify(&mut self, ejector: ServiceId) {
		zombify(ejector);
	}
}