Function holochain::core::workflow::sys_validation_workflow::sys_validate_record

pub async fn sys_validate_record(
    record: &Record,
    call_zome_workspace: &HostFnWorkspace,
    network: HolochainP2pDna,
    conductor_handle: &Conductor
) -> SysValidationOutcome<()>

Direct system validation call that takes a Record instead of an op. Does not require holding dependencies. Will not await dependencies and instead returns that outcome immediately.

Examples found in repository

src/core/workflow/call_zome_workflow.rs (line 242)

pub async fn inline_validation<Ribosome>(
    workspace: SourceChainWorkspace,
    network: HolochainP2pDna,
    conductor_handle: ConductorHandle,
    ribosome: Ribosome,
) -> WorkflowResult<()>
where
    Ribosome: RibosomeT + 'static,
{
    let to_app_validate = {
        // collect all the records we need to validate in wasm
        let scratch_records = workspace.source_chain().scratch_records()?;
        let mut to_app_validate: Vec<Record> = Vec::with_capacity(scratch_records.len());
        // Loop forwards through all the new records
        for record in scratch_records {
            sys_validate_record(&record, &workspace, network.clone(), &(*conductor_handle))
                .await
                // If the was en error exit
                // If the validation failed, exit with an InvalidCommit
                // If it was ok continue
                .or_else(|outcome_or_err| outcome_or_err.invalid_call_zome_commit())?;
            to_app_validate.push(record);
        }

        to_app_validate
    };

    let mut cascade =
        holochain_cascade::Cascade::from_workspace_and_network(&workspace, network.clone());
    for mut chain_record in to_app_validate {
        for op_type in action_to_op_types(chain_record.action()) {
            let op =
                app_validation_workflow::record_to_op(chain_record, op_type, &mut cascade).await;

            let (op, activity_entry) = match op {
                Ok(op) => op,
                Err(outcome_or_err) => return map_outcome(Outcome::try_from(outcome_or_err)),
            };

            let outcome = app_validation_workflow::validate_op(
                &op,
                workspace.clone().into(),
                &network,
                &ribosome,
            )
            .await;
            let outcome = outcome.or_else(Outcome::try_from);
            map_outcome(outcome)?;
            chain_record = app_validation_workflow::op_to_record(op, activity_entry);
        }
    }

    Ok(())
}