Struct sp_runtime::offchain::LimitedExternalities

pub struct LimitedExternalities<T> { /* fields omitted */ }

An *Externalities implementation with limited capabilities.

Implementations

impl<T> LimitedExternalities<T>

pub fn new(
    capabilities: Capabilities,
    externalities: T
) -> LimitedExternalities<T>

Create new externalities limited to given capabilities.

Trait Implementations

impl<T> DbExternalities for LimitedExternalities<T> where
    T: DbExternalities, 

pub fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8])

Sets a value in the local storage.

pub fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8])

Removes a value in the local storage.

pub fn local_storage_compare_and_set(
    &mut self,
    kind: StorageKind,
    key: &[u8],
    old_value: Option<&[u8]>,
    new_value: &[u8]
) -> bool

Sets a value in the local storage if it matches current value.

pub fn local_storage_get(
    &mut self,
    kind: StorageKind,
    key: &[u8]
) -> Option<Vec<u8, Global>>

Gets a value from the local storage.

impl<T> Externalities for LimitedExternalities<T> where
    T: Externalities, 

pub fn is_validator(&self) -> bool

Returns if the local node is a potential validator.

pub fn network_state(&self) -> Result<OpaqueNetworkState, ()>

Returns information about the local node’s network state.

pub fn timestamp(&mut self) -> Timestamp

Returns current UNIX timestamp (in millis)

pub fn sleep_until(&mut self, deadline: Timestamp)

Pause the execution until deadline is reached.

pub fn random_seed(&mut self) -> [u8; 32]

Returns a random seed.

pub fn http_request_start(
    &mut self,
    method: &str,
    uri: &str,
    meta: &[u8]
) -> Result<HttpRequestId, ()>

Initiates a http request given HTTP verb and the URL.

pub fn http_request_add_header(
    &mut self,
    request_id: HttpRequestId,
    name: &str,
    value: &str
) -> Result<(), ()>

Append header to the request.

pub fn http_request_write_body(
    &mut self,
    request_id: HttpRequestId,
    chunk: &[u8],
    deadline: Option<Timestamp>
) -> Result<(), HttpError>

Write a chunk of request body.

pub fn http_response_wait(
    &mut self,
    ids: &[HttpRequestId],
    deadline: Option<Timestamp>
) -> Vec<HttpRequestStatus, Global>

Block and wait for the responses for given requests.

pub fn http_response_headers(
    &mut self,
    request_id: HttpRequestId
) -> Vec<(Vec<u8, Global>, Vec<u8, Global>), Global>

Read all response headers.

pub fn http_response_read_body(
    &mut self,
    request_id: HttpRequestId,
    buffer: &mut [u8],
    deadline: Option<Timestamp>
) -> Result<usize, HttpError>

Read a chunk of body response to given buffer.

pub fn set_authorized_nodes(
    &mut self,
    nodes: Vec<OpaquePeerId, Global>,
    authorized_only: bool
)

Set the authorized nodes from runtime.