Struct holochain::core::ribosome::ZomeCallInvocation

pub struct ZomeCallInvocation {
    pub cell_id: CellId,
    pub zome: Zome,
    pub cap_secret: Option<CapSecret>,
    pub fn_name: FunctionName,
    pub payload: ExternIO,
    pub provenance: AgentPubKey,
    pub signature: Signature,
    pub nonce: Nonce256Bits,
    pub expires_at: Timestamp,
}

A top-level call into a zome function, i.e. coming from outside the Cell from an external Interface

Fields

cell_id: CellId

The Id of the Cell in which this Zome-call would be invoked

zome: Zome

The Zome containing the function that would be invoked

cap_secret: Option<CapSecret>

The capability request authorization. This can be None and still succeed in the case where the function in the zome being called has been given an Unrestricted status via a CapGrant. Otherwise, it will be necessary to provide a CapSecret for every call.

fn_name: FunctionName

The name of the Zome function to call

payload: ExternIO

The serialized data to pass as an argument to the Zome call

provenance: AgentPubKey

The provenance of the call. Provenance means the ‘source’ so this expects the AgentPubKey of the agent calling the Zome function

signature: Signature

The signature of the call from the provenance of the call. Everything except the signature itself is signed.

nonce: Nonce256Bits

The nonce of the call. Must be unique and monotonic. If a higher nonce has been seen then older zome calls will be discarded.

expires_at: Timestamp

This call MUST NOT be respected after this time, in the opinion of the callee.

Implementations

impl ZomeCallInvocation

pub async fn verify_signature(&self) -> RibosomeResult<ZomeCallAuthorization>

pub async fn verify_grant(
    &self,
    host_access: &ZomeCallHostAccess
) -> RibosomeResult<ZomeCallAuthorization>

to decide if a zome call grant is authorized:

• we need to find a live (committed and not deleted) cap grant that matches the secret
• if the live cap grant is for the current author the call is ALWAYS authorized ELSE
• the live cap grant needs to include the invocation’s provenance AND zome/function name

pub async fn verify_nonce(
    &self,
    host_access: &ZomeCallHostAccess
) -> RibosomeResult<ZomeCallAuthorization>

pub async fn is_authorized<'a>(
    &self,
    host_access: &ZomeCallHostAccess
) -> RibosomeResult<ZomeCallAuthorization>

to verify if the zome call is authorized:

• the signature must be valid
• the nonce must not have already been seen
• the grant must be valid the checks MUST be done in this order as witnessing the nonce is a write and so we MUST NOT write nonces until after we verify the signature.

impl ZomeCallInvocation

pub async fn try_from_interface_call(
    conductor_api: CellConductorHandle,
    call: ZomeCall
) -> RibosomeResult<Self>

Trait Implementations

impl Clone for ZomeCallInvocation

fn clone(&self) -> ZomeCallInvocation

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ZomeCallInvocation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ZomeCallInvocation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ZomeCallInvocation> for ZomeCall

fn from(inv: ZomeCallInvocation) -> Self

Converts to this type from the input type.

impl Invocation for ZomeCallInvocation

fn zomes(&self) -> ZomesToInvoke

Some invocations call into a single zome and some call into many or all zomes. An example of an invocation that calls across all zomes is init. Init must pass for every zome in order for the Dna overall to successfully init. An example of an invocation that calls a single zome is validation of an entry, because the entry is only defined in a single zome, so it only makes sense for that exact zome to define the validation logic for that entry. In the future this may be expanded to support a subset of zomes that is larger than one. For example, we may want to trigger a callback in all zomes that implement a trait/interface, but this doesn’t exist yet, so the only valid options are All or One.

fn fn_components(&self) -> FnComponents

Invocations execute in a “sparse” manner of decreasing specificity. In technical terms this means that the list of strings in FnComponents will be concatenated into a single function name to be called, then the last string will be removed and a shorter function name will be attempted and so on until all variations have been attempted. For example, if FnComponents was vec![“foo”, “bar”, “baz”] it would loop as “foo_bar_baz” then “foo_bar” then “foo”. All of those three callbacks that are defined will be called unless a definitive callback result is returned. See CallbackResult::is_definitive in zome_types. All of the individual callback results are then folded into a single overall result value as a From implementation on the invocation results structs (e.g. zome results vs. ribosome results).

fn host_input(self) -> Result<ExternIO, SerializedBytesError>

the serialized input from the host for the wasm call this is intentionally NOT a reference to self because ExternIO may be huge we want to be careful about cloning invocations

fn auth(&self) -> InvocationAuth

impl Serialize for ZomeCallInvocation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.