Struct AttestationDataBuilder

pub struct AttestationDataBuilder {
    pub recipient: Option<Address>,
    pub expiration_time: Option<u64>,
    pub revocable: bool,
    pub ref_uid: Option<[u8; 32]>,
    pub data: Option<Bytes>,
    pub value: Option<U256>,
}

Fields

recipient: Option<Address>

expiration_time: Option<u64>

revocable: bool

ref_uid: Option<[u8; 32]>

data: Option<Bytes>

value: Option<U256>

Implementations

impl AttestationDataBuilder

pub fn new() -> Self

Examples found in repository

examples/schema.rs (line 40)

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(())
}

examples/attestation.rs (line 24)

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_id =
        H256::from_str("0x0cf8b15034904dc56810da6237d220c345693077c4d42c53c45263649ed3b585")?;

    let attestation_request = AttestationDataBuilder::new()
        .revocable(true)
        .data(&[
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Int(11.into()),
        ])
        .build();

    // attest sends a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.attest(&schema_id, attestation_request).await?;
    let attested = tx.await?;

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

    // timestamp send a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.timestamp(attested.uid).await?;
    let timestamped = tx.await?;

    println!("Timestamped: {:?}", timestamped);

    // revoke send a transaction and returns a PendingTx that can be awaited
    let revoked = client
        .eas
        .revoke(attested.schema, attested.uid, U256::default())
        .await?;

    let revoked = revoked.await?;

    println!("Revoked: {:?}", revoked);

    Ok(())
}

pub fn recipient(self, recipient: Address) -> Self

pub fn expiration_time(self, expiration_time: u64) -> Self

pub fn revocable(self, revocable: bool) -> Self

Examples found in repository

examples/schema.rs (line 41)

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(())
}

examples/attestation.rs (line 25)

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_id =
        H256::from_str("0x0cf8b15034904dc56810da6237d220c345693077c4d42c53c45263649ed3b585")?;

    let attestation_request = AttestationDataBuilder::new()
        .revocable(true)
        .data(&[
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Int(11.into()),
        ])
        .build();

    // attest sends a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.attest(&schema_id, attestation_request).await?;
    let attested = tx.await?;

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

    // timestamp send a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.timestamp(attested.uid).await?;
    let timestamped = tx.await?;

    println!("Timestamped: {:?}", timestamped);

    // revoke send a transaction and returns a PendingTx that can be awaited
    let revoked = client
        .eas
        .revoke(attested.schema, attested.uid, U256::default())
        .await?;

    let revoked = revoked.await?;

    println!("Revoked: {:?}", revoked);

    Ok(())
}

pub fn ref_uid(self, ref_uid: [u8; 32]) -> Self

pub fn data(self, data: &[Token]) -> Self

Examples found in repository

examples/schema.rs (line 42)

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(())
}

examples/attestation.rs (lines 26-30)

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_id =
        H256::from_str("0x0cf8b15034904dc56810da6237d220c345693077c4d42c53c45263649ed3b585")?;

    let attestation_request = AttestationDataBuilder::new()
        .revocable(true)
        .data(&[
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Int(11.into()),
        ])
        .build();

    // attest sends a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.attest(&schema_id, attestation_request).await?;
    let attested = tx.await?;

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

    // timestamp send a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.timestamp(attested.uid).await?;
    let timestamped = tx.await?;

    println!("Timestamped: {:?}", timestamped);

    // revoke send a transaction and returns a PendingTx that can be awaited
    let revoked = client
        .eas
        .revoke(attested.schema, attested.uid, U256::default())
        .await?;

    let revoked = revoked.await?;

    println!("Revoked: {:?}", revoked);

    Ok(())
}

pub fn value(self, value: U256) -> Self

pub fn build(self) -> AttestationData

Examples found in repository

examples/schema.rs (line 43)

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(())
}

examples/attestation.rs (line 31)

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_id =
        H256::from_str("0x0cf8b15034904dc56810da6237d220c345693077c4d42c53c45263649ed3b585")?;

    let attestation_request = AttestationDataBuilder::new()
        .revocable(true)
        .data(&[
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Address(H160::from_low_u64_be(0x1234567890abcdef)),
            Token::Int(11.into()),
        ])
        .build();

    // attest sends a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.attest(&schema_id, attestation_request).await?;
    let attested = tx.await?;

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

    // timestamp send a transaction and returns a PendingTx that can be awaited
    let tx = client.eas.timestamp(attested.uid).await?;
    let timestamped = tx.await?;

    println!("Timestamped: {:?}", timestamped);

    // revoke send a transaction and returns a PendingTx that can be awaited
    let revoked = client
        .eas
        .revoke(attested.schema, attested.uid, U256::default())
        .await?;

    let revoked = revoked.await?;

    println!("Revoked: {:?}", revoked);

    Ok(())
}

Trait Implementations

impl Default for AttestationDataBuilder

fn default() -> Self

Returns the “default value” for a type.