Struct Store 

pub struct Store { /* private fields */ }

Meta Storage(CAS)

In-memory CAS (content addressed storage) for Rain metadata which basically stores k/v pairs of meta hash, meta bytes and ExpressionDeployer reproducible data as well as providing functionalities to easliy read/write to the CAS.

Hashes are normal bytes and meta bytes are valid cbor encoded as data bytes. ExpressionDeployers data are in form of a struct mapped to deployedBytecode meta hash and deploy transaction hash.

Examples

use rain_metadata::Store;
use rain_metadata::meta::cache::{DeployerCache, MetaCache};
use std::collections::HashMap;

// to instantiate with an empty subgraph list
let mut store = Store::new();

// or to instantiate with initial values
let mut store = Store::create(
    &vec!["sg-url-1".to_string()],
    &MetaCache::default(),
    &DeployerCache::default(),
    &HashMap::new(),
);

// add a new subgraph endpoint url to the subgraph list
store.add_subgraphs(&vec!["sg-url-2".to_string()]);

// merge another Store into this one
store.merge(&Store::new());

// updates the meta store with some bytes and the hash they hash to - a
// pair that does not is refused, so the hash is derived rather than picked
let bytes = vec![0u8, 1u8];
let hash = alloy::primitives::keccak256(&bytes).0.to_vec();
store.update_with(&hash, &bytes).unwrap();

// `Store::update(&hash)` is async; it searches each subgraph for `hash` and
// populates the cache with the result. Call it from an async context with `.await`.

// to get a record from the store
let _meta = store.get_meta(&hash);

// to get a deployer record from the store
let _deployer_record = store.get_deployer(&hash);

// Store is agnostic to dotrain contents — it just maps the hash of the content
// to the given uri and puts it as a new meta into the meta cache.
let dotrain_uri = "path/to/file.rain";
let dotrain_content = "/* some dotrain source */";
let (_new_hash, _old_hash) = store
    .set_dotrain(dotrain_content, dotrain_uri, false)
    .unwrap();

// to get dotrain meta bytes given a uri
let _dotrain_meta_bytes = store.get_dotrain_meta(dotrain_uri);

Implementations

impl Store

pub fn new() -> Store

lazily creates a new instance with no subgraphs it is recommended to use create() instead with initial values

pub fn create( subgraphs: &Vec<String>, cache: &MetaCache, deployer_cache: &DeployerCache, dotrain_cache: &HashMap<String, Vec<u8>>, ) -> Store

creates new instance of Store with given initial values it checks the validity of each item of the provided values and only stores those that are valid

pub fn subgraphs(&self) -> &Vec<String>

all subgraph endpoints in this instance

pub fn add_subgraphs(&mut self, subgraphs: &Vec<String>)

add new subgraph endpoints

pub fn cache(&self) -> &MetaCache

getter method for the whole meta cache

pub fn get_meta(&self, hash: &[u8]) -> Option<&Vec<u8>>

get the corresponding meta bytes of the given hash if it exists

pub fn deployer_cache(&self) -> &DeployerCache

getter method for the whole authoring meta cache

pub fn get_deployer(&self, hash: &[u8]) -> Option<&NPE2Deployer>

get the corresponding DeployerNPRecord of the given deployer hash if it exists

pub async fn search_deployer( &mut self, hash: &[u8], ) -> Result<&NPE2Deployer, Error>

searches for DeployerNPRecord in the subgraphs given the deployer hash. The meta bytes it carries go through Self::insert_verified like every other write to the meta cache, so a deployer record cannot smuggle in bytes that do not hash to the meta hash it claims for them.

pub async fn search_deployer_check( &mut self, hash: &[u8], ) -> Result<&NPE2Deployer, Error>

if the NPE2Deployer record already is cached it returns it immediately else searches for NPE2Deployer in the subgraphs given the deployer hash

pub fn set_deployer_from_query_response( &mut self, deployer_query_response: DeployerResponse, ) -> Result<NPE2Deployer, Error>

sets deployer record from the deployer query response

pub fn set_deployer( &mut self, hash: &[u8], npe2_deployer: &NPE2Deployer, tx_hash: Option<&[u8]>, ) -> Result<(), Error>

sets NPE2Deployer record, and its constructor meta in the meta cache

Errors without writing anything if hash is not a 32 byte hash, the record is missing a field needed to reproduce the deployer, or its meta bytes do not hash to the meta hash it claims for them.

pub fn dotrain_cache(&self) -> &HashMap<String, Vec<u8>>

getter method for the whole dotrain cache

pub fn get_dotrain_hash(&self, uri: &str) -> Option<&Vec<u8>>

get the corresponding dotrain hash of the given dotrain uri if it exists

pub fn get_dotrain_uri(&self, hash: &[u8]) -> Option<&String>

get the corresponding uri of the given dotrain hash if it exists

pub fn get_dotrain_meta(&self, uri: &str) -> Option<&Vec<u8>>

get the corresponding meta bytes of the given dotrain uri if it exists

pub fn delete_dotrain(&mut self, uri: &str, keep_meta: bool)

deletes a dotrain record given a uri

pub fn merge(&mut self, other: &Store)

lazilly merges another Store to the current one, avoids duplicates every map keeps the entry this Store already has on a key collision

pub async fn update(&mut self, hash: &[u8]) -> Result<&Vec<u8>, Error>

updates the meta cache by searching through all subgraphs for the given hash, and returns the reference to the meta bytes in the cache if it was found. Refreshes unconditionally; Self::update_check is the variant that leaves an already cached hash alone.

pub async fn update_check(&mut self, hash: &[u8]) -> Result<&Vec<u8>, Error>

first checks if the meta is stored, if not will perform update()

pub fn update_with( &mut self, hash: &[u8], bytes: &[u8], ) -> Result<&Vec<u8>, Error>

updates the meta cache with the given hash and meta bytes, and returns the reference to the bytes if they were accepted. Leaves an already cached hash alone, as Self::update_check does for the subgraph path.

pub fn set_dotrain( &mut self, text: &str, uri: &str, keep_old: bool, ) -> Result<(Vec<u8>, Vec<u8>), Error>

stores (or updates in case the URI already exists) the given dotrain text as meta into the store cache and maps it to the given uri (path), it should be noted that reading the content of the dotrain is not in the scope of Store and handling and passing on a correct URI (path) for the given text must be handled externally by the implementer

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Store

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

Formats the value using the given formatter.

impl Default for Store

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Store

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Store

fn eq(&self, other: &Store) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Store

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Store