Struct axiom_sdk::HiLo

pub struct HiLo<T>(/* private fields */);

Stored as [lo, hi], just like Word2

Implementations

impl<T> HiLo<T>

pub fn from_lo_hi(_: [T; 2]) -> HiLo<T>

Create a new HiLo from a [lo, hi] array.

pub fn from_hi_lo(_: [T; 2]) -> HiLo<T>

Create a new HiLo from a [hi, lo] array.

Examples found in repository

examples/quickstart.rs (line 58)

    fn compute(
        api: &mut AxiomAPI,
        assigned_inputs: QuickstartCircuitInput<AssignedValue<Fr>>,
    ) -> Vec<AxiomResult> {
        // fetch block header data
        // access the timestamp field
        let _timestamp = api
            .get_header(assigned_inputs.block)
            .call(HeaderField::Timestamp);
        // access the gasLimit field
        let _gas_limit = api
            .get_header(assigned_inputs.block)
            .call(HeaderField::GasLimit);

        // fetch account data
        // access the account balance
        let _balance = api
            .get_account(assigned_inputs.block, assigned_inputs.addr)
            .call(AccountField::Balance);
        // access the account nonce
        let _nonce = api
            .get_account(assigned_inputs.block, assigned_inputs.addr)
            .call(AccountField::Nonce);

        //fetch storage data
        let storage = api.get_storage(assigned_inputs.block, assigned_inputs.addr);
        let _slot_val = storage.slot(assigned_inputs.slot);

        //fetch Solidity mapping data
        let key = [0, 3].map(|i| api.ctx().load_constant(Fr::from(i)));
        let mapping = api.get_mapping(
            assigned_inputs.block,
            assigned_inputs.addr,
            assigned_inputs.mapping_slot,
        );
        let _mapping_val = mapping.key(HiLo::from_hi_lo(key));

        // fetch transaction data, example is for the transaction below:
        // https://sepolia.etherscan.io/tx/0xf518bd931eae8dc4178e1f8a3b64d6312af33f8c5df0c2cd4a38b72f4fb2d7dc
        // get the 4-byte function selector that was called
        let _function_selector = api
            .get_tx(assigned_inputs.tx_block_number, assigned_inputs.tx_idx)
            .call(TxField::FunctionSelector);
        // access bytes [32, 64) of calldata
        let calldata_idx = api.ctx().load_constant(Fr::from(1));
        let _calldata = api
            .get_tx(assigned_inputs.tx_block_number, assigned_inputs.tx_idx)
            .calldata(calldata_idx);

        // fetch receipt data, example is for the first event log in the transaction below
        // Transfer (index_topic_1 address from, index_topic_2 address to, uint256 tokens)
        // https://sepolia.etherscan.io/tx/0xf518bd931eae8dc4178e1f8a3b64d6312af33f8c5df0c2cd4a38b72f4fb2d7dc#eventlog
        // eventSchema = keccak(Transfer(address,address,uint256))
        let event_schema =
            H256::from_str("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
                .unwrap();
        let log_idx = api.ctx().load_constant(Fr::from(0));
        let topic_idx = api.ctx().load_constant(Fr::from(1));
        let data_idx = api.ctx().load_constant(Fr::from(0));
        // access the address that emitted the log event at index 0
        let _addr = api
            .get_receipt(assigned_inputs.tx_block_number, assigned_inputs.tx_idx)
            .log(log_idx)
            .address();
        // access the topic at index 1 of the log event at index 0 and check it has schema eventSchema
        // because `address` is indexed in the event, this corresponds to `address`
        let _topic = api
            .get_receipt(assigned_inputs.tx_block_number, assigned_inputs.tx_idx)
            .log(log_idx)
            .topic(topic_idx, Some(event_schema));
        // access the first 32 bytes of data in the log event at index 0
        // because `amt` is not indexed, this corresponds to `amt`
        let _data = api
            .get_receipt(assigned_inputs.tx_block_number, assigned_inputs.tx_idx)
            .log(log_idx)
            .data(data_idx, Some(event_schema));

        vec![]
    }

pub fn hi(&self) -> T

where T: Copy,

pub fn lo(&self) -> T

where T: Copy,

pub fn hi_lo(&self) -> [T; 2]

where T: Copy,

pub fn flatten(&self) -> [T; 2]

where T: Copy,

impl<F> HiLo<F>

where F: Field,

pub fn assign(&self, ctx: &mut Context<F>) -> HiLo<AssignedValue<F>>

Trait Implementations

impl<T> Clone for HiLo<T>

where T: Clone,

fn clone(&self) -> HiLo<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for HiLo<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for HiLo<T>

where T: Default,

fn default() -> HiLo<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for HiLo<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D ) -> Result<HiLo<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> FixLenLogical<T> for HiLo<T>

where T: Copy,

fn get_field_size() -> &'static [usize]

Get field size of this logical.

fn get_num_fields() -> usize

Get number of fields of this logical.

fn try_from_raw(fields: Vec<T>) -> Result<Self, Error>

From raw vec to logical.

fn into_raw(self) -> Vec<T>

Into raw vec.

impl From<HiLo<AssignedValue<Fr>>> for AxiomResult

fn from(result: HiLo<AssignedValue<Fr>>) -> Self

Converts to this type from the input type.

impl<F> From<H256> for HiLo<F>

where F: Field,

fn from(value: H256) -> HiLo<F>

Converts to this type from the input type.

impl<T> From<Word<T>> for HiLo<T>

where T: Clone,

fn from(word: Word<T>) -> HiLo<T>

Converts to this type from the input type.

impl<T> Hash for HiLo<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> InputFlatten<T> for HiLo<T>

where T: Copy,

const NUM_FE: usize = 2usize

fn flatten_vec(&self) -> Vec<T>

fn unflatten(vec: Vec<T>) -> Result<HiLo<T>, Error>

impl<T> PartialEq for HiLo<T>

where T: PartialEq,

fn eq(&self, other: &HiLo<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for HiLo<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TryFrom<Flatten<T>> for HiLo<T>

where T: Copy,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Flatten<T>) -> Result<HiLo<T>, Error>

Performs the conversion.

impl<T> TryFrom<Vec<T>> for HiLo<T>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<HiLo<T>, Error>

Performs the conversion.

impl<T> Copy for HiLo<T>

where T: Copy,

impl<T> Eq for HiLo<T>

where T: Eq,

impl<T> StructuralPartialEq for HiLo<T>