Struct SchemaRegistry

pub struct SchemaRegistry<M: Middleware> { /* private fields */ }

Implementations

impl<M: Middleware + 'static> SchemaRegistry<M>

pub fn new(contract: Contract<M>) -> Self

pub async fn register<T: Into<String>>( &self, schema: T, resolver: Option<Address>, revocable: bool, ) -> Result<PendingTx<SchemaRegistryRegistered>, SchemaRegistryError<M>>

Examples found in repository

examples/schema.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    let singing_key = &hex::decode(SEPOLIA_PRIVATE_KEY_HEX)?;
    let signing_key = SigningKey::from_slice(singing_key)?;
    let contract_address = H160::from_str(SEPOLIA_CONTRACT_ADDRESS)?;
    let client = client::Client::new(SEPOLIA_ENDPOINT, contract_address, None, signing_key).await?;

    let schema = schema::SchemaBuilder::new()
        .add("id", schema::Type::Address)
        .add("voter_id", schema::Type::Address)
        .add("vote_option", schema::Type::Int(32))
        .build();

    let tx = client.schema_registry.register(schema, None, true).await?;
    let registered_schema = tx.await?;

    println!("Schema ID: {:?}", registered_schema.schema_uid);

    let naming_schema =
        H256::from_str("0x44d562ac1d7cd77e232978687fea027ace48f719cf1d58c7888e509663bb87fc")?;

    let data = &[
        Token::FixedBytes(registered_schema.schema_uid.as_bytes().into()),
        Token::String("enter schema name here".to_string()),
    ];

    let attestation_data = AttestationDataBuilder::new()
        .revocable(true)
        .data(data)
        .build();

    let attested = client.eas.attest(&naming_schema, attestation_data).await?;
    let attested = attested.await?;

    println!("Attestation ID: {:?}", attested);

    Ok(())
}

pub async fn get_schema( &self, schema_uid: H256, ) -> Result<Schema, SchemaRegistryError<M>>

pub async fn version(&self) -> Result<String, SchemaRegistryError<M>>

pub fn registered_event<T>( &self, start_block: T, end_block: Option<T>, uids: Option<Vec<H256>>, ) -> SchemaRegisteredEvent<M>

where T: Into<BlockNumber>,

pub fn contract(&self) -> &Contract<M>