use crate::{JamAccumulateOps, JamLogger, JamOuterVm};
use codec::DecodeAll;
use corevm_engine::{AccumulateEngine, Engine};
use jam_pvm_common::accumulate;
use jam_types::{
AccumulateItem, CoreIndex, Encode, Hash, ServiceId, Slot, TransferRecord, WorkItemRecord,
WorkOutput, WorkPackageHash, WorkPayload,
};
use log::debug;
pub struct Service;
jam_pvm_common::declare_service!(Service);
impl jam_pvm_common::Service for Service {
fn refine(
_core_index: CoreIndex,
_item_index: usize,
_service_id: ServiceId,
payload: WorkPayload,
_package_hash: WorkPackageHash,
) -> WorkOutput {
JamLogger::init();
let payload = DecodeAll::decode_all(&mut &payload[..]).expect("Failed to decode payload");
let outer_vm = JamOuterVm::new().expect("Failed to initialize outer VM");
let engine = Engine::new(payload, outer_vm).expect("Failed to create engine");
let (output, _outer_vm) = engine.run().expect("Failed to execute the code");
WorkOutput(output.encode())
}
fn accumulate(_slot: Slot, _id: ServiceId, _item_count: usize) -> Option<Hash> {
JamLogger::init();
let items = accumulate::accumulate_items();
let mut engine = AccumulateEngine::new(JamAccumulateOps);
let results = engine.run(&items);
for (result, item) in results.into_iter().zip(items.into_iter()) {
match item {
AccumulateItem::WorkItem(WorkItemRecord { package, .. }) => match result {
Ok(()) => debug!("Accumulated package {package}"),
Err(e) => debug!("Failed to accumulate package {package}: {e:?}"),
},
AccumulateItem::Transfer(TransferRecord {
amount, source, destination, ..
}) => match result {
Ok(()) => debug!("Transferred {amount} from {source:x} to {destination:x}",),
Err(e) => debug!(
"Failed to transfer {amount} from {source:x} to {destination:x}: {e:?}",
),
},
}
}
None
}
}