pragma_lib

Fully qualified path: pragma_lib

Modules

Modules

Modules

abi

Fully qualified path: pragma_lib::abi

Modules

Traits

Impls

Groups:

dispatchers

• Structs

• Traits

• Impls

Modules

Modules

__external_IPragmaABIForwardImpl

Fully qualified path: pragma_lib::abi::__external_IPragmaABIForwardImpl

__l1_handler_IPragmaABIForwardImpl

Fully qualified path: pragma_lib::abi::__l1_handler_IPragmaABIForwardImpl

__constructor_IPragmaABIForwardImpl

Fully qualified path: pragma_lib::abi::__constructor_IPragmaABIForwardImpl

__external_ISummaryStatsABIForwardImpl

Fully qualified path: pragma_lib::abi::__external_ISummaryStatsABIForwardImpl

__l1_handler_ISummaryStatsABIForwardImpl

Fully qualified path: pragma_lib::abi::__l1_handler_ISummaryStatsABIForwardImpl

__constructor_ISummaryStatsABIForwardImpl

Fully qualified path: pragma_lib::abi::__constructor_ISummaryStatsABIForwardImpl

__external_IYieldCurveABIForwardImpl

Fully qualified path: pragma_lib::abi::__external_IYieldCurveABIForwardImpl

__l1_handler_IYieldCurveABIForwardImpl

Fully qualified path: pragma_lib::abi::__l1_handler_IYieldCurveABIForwardImpl

__constructor_IYieldCurveABIForwardImpl

Fully qualified path: pragma_lib::abi::__constructor_IYieldCurveABIForwardImpl

__external_IRandomnessForwardImpl

Fully qualified path: pragma_lib::abi::__external_IRandomnessForwardImpl

__l1_handler_IRandomnessForwardImpl

Fully qualified path: pragma_lib::abi::__l1_handler_IRandomnessForwardImpl

__constructor_IRandomnessForwardImpl

Fully qualified path: pragma_lib::abi::__constructor_IRandomnessForwardImpl

__external_IOptimisticOracleForwardImpl

Fully qualified path: pragma_lib::abi::__external_IOptimisticOracleForwardImpl

__l1_handler_IOptimisticOracleForwardImpl

Fully qualified path: pragma_lib::abi::__l1_handler_IOptimisticOracleForwardImpl

__constructor_IOptimisticOracleForwardImpl

Fully qualified path: pragma_lib::abi::__constructor_IOptimisticOracleForwardImpl

Traits

Traits

IPragmaABI

Fully qualified path: pragma_lib::abi::IPragmaABI

trait IPragmaABI<TContractState>

Trait functions

get_decimals

Fully qualified path: pragma_lib::abi::IPragmaABI::get_decimals

fn get_decimals(self: @TContractState, data_type: DataType) -> u32

get_data_median

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_median

fn get_data_median(self: @TContractState, data_type: DataType) -> PragmaPricesResponse

get_data_median_for_sources

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_median_for_sources

fn get_data_median_for_sources(
    self: @TContractState, data_type: DataType, sources: Span<felt252>,
) -> PragmaPricesResponse

get_data

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data

fn get_data(
    self: @TContractState, data_type: DataType, aggregation_mode: AggregationMode,
) -> PragmaPricesResponse

get_data_median_multi

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_median_multi

fn get_data_median_multi(
    self: @TContractState, data_types: Span<DataType>, sources: Span<felt252>,
) -> Span<PragmaPricesResponse>

get_data_entry

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_entry

fn get_data_entry(self: @TContractState, data_type: DataType, source: felt252) -> PossibleEntries

get_data_for_sources

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_for_sources

fn get_data_for_sources(
    self: @TContractState,
    data_type: DataType,
    aggregation_mode: AggregationMode,
    sources: Span<felt252>,
) -> PragmaPricesResponse

get_data_entries

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_entries

fn get_data_entries(self: @TContractState, data_type: DataType) -> Span<PossibleEntries>

get_data_entries_for_sources

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_entries_for_sources

fn get_data_entries_for_sources(
    self: @TContractState, data_type: DataType, sources: Span<felt252>,
) -> (Span<PossibleEntries>, u64)

get_last_checkpoint_before

Fully qualified path: pragma_lib::abi::IPragmaABI::get_last_checkpoint_before

fn get_last_checkpoint_before(
    self: @TContractState, data_type: DataType, timestamp: u64, aggregation_mode: AggregationMode,
) -> (Checkpoint, u64)

get_data_with_USD_hop

Fully qualified path: pragma_lib::abi::IPragmaABI::get_data_with_USD_hop

fn get_data_with_USD_hop(
    self: @TContractState,
    base_currency_id: felt252,
    quote_currency_id: felt252,
    aggregation_mode: AggregationMode,
    typeof: SimpleDataType,
    expiration_timestamp: Option<u64>,
) -> PragmaPricesResponse

get_publisher_registry_address

Fully qualified path: pragma_lib::abi::IPragmaABI::get_publisher_registry_address

fn get_publisher_registry_address(self: @TContractState) -> ContractAddress

get_latest_checkpoint_index

Fully qualified path: pragma_lib::abi::IPragmaABI::get_latest_checkpoint_index

fn get_latest_checkpoint_index(
    self: @TContractState, data_type: DataType, aggregation_mode: AggregationMode,
) -> (u64, bool)

get_latest_checkpoint

Fully qualified path: pragma_lib::abi::IPragmaABI::get_latest_checkpoint

fn get_latest_checkpoint(
    self: @TContractState, data_type: DataType, aggregation_mode: AggregationMode,
) -> Checkpoint

get_checkpoint

Fully qualified path: pragma_lib::abi::IPragmaABI::get_checkpoint

fn get_checkpoint(
    self: @TContractState,
    data_type: DataType,
    checkpoint_index: u64,
    aggregation_mode: AggregationMode,
) -> Checkpoint

get_sources_threshold

Fully qualified path: pragma_lib::abi::IPragmaABI::get_sources_threshold

fn get_sources_threshold(self: @TContractState) -> u32

get_admin_address

Fully qualified path: pragma_lib::abi::IPragmaABI::get_admin_address

fn get_admin_address(self: @TContractState) -> ContractAddress

get_implementation_hash

Fully qualified path: pragma_lib::abi::IPragmaABI::get_implementation_hash

fn get_implementation_hash(self: @TContractState) -> ClassHash

publish_data

Fully qualified path: pragma_lib::abi::IPragmaABI::publish_data

fn publish_data(ref self: TContractState, new_entry: PossibleEntries)

publish_data_entries

Fully qualified path: pragma_lib::abi::IPragmaABI::publish_data_entries

fn publish_data_entries(ref self: TContractState, new_entries: Span<PossibleEntries>)

set_admin_address

Fully qualified path: pragma_lib::abi::IPragmaABI::set_admin_address

fn set_admin_address(ref self: TContractState, new_admin_address: ContractAddress)

update_publisher_registry_address

Fully qualified path: pragma_lib::abi::IPragmaABI::update_publisher_registry_address

fn update_publisher_registry_address(
    ref self: TContractState, new_publisher_registry_address: ContractAddress,
)

add_currency

Fully qualified path: pragma_lib::abi::IPragmaABI::add_currency

fn add_currency(ref self: TContractState, new_currency: Currency)

update_currency

Fully qualified path: pragma_lib::abi::IPragmaABI::update_currency

fn update_currency(ref self: TContractState, currency_id: felt252, currency: Currency)

add_pair

Fully qualified path: pragma_lib::abi::IPragmaABI::add_pair

fn add_pair(ref self: TContractState, new_pair: Pair)

set_checkpoint

Fully qualified path: pragma_lib::abi::IPragmaABI::set_checkpoint

fn set_checkpoint(ref self: TContractState, data_type: DataType, aggregation_mode: AggregationMode)

set_checkpoints

Fully qualified path: pragma_lib::abi::IPragmaABI::set_checkpoints

fn set_checkpoints(
    ref self: TContractState, data_types: Span<DataType>, aggregation_mode: AggregationMode,
)

set_sources_threshold

Fully qualified path: pragma_lib::abi::IPragmaABI::set_sources_threshold

fn set_sources_threshold(ref self: TContractState, threshold: u32)

upgrade

Fully qualified path: pragma_lib::abi::IPragmaABI::upgrade

fn upgrade(ref self: TContractState, impl_hash: ClassHash)

ISummaryStatsABI

Fully qualified path: pragma_lib::abi::ISummaryStatsABI

trait ISummaryStatsABI<TContractState>

Trait functions

calculate_mean

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::calculate_mean

fn calculate_mean(
    self: @TContractState,
    data_type: DataType,
    start: u64,
    stop: u64,
    aggregation_mode: AggregationMode,
) -> (u128, u32)

calculate_volatility

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::calculate_volatility

fn calculate_volatility(
    self: @TContractState,
    data_type: DataType,
    start_tick: u64,
    end_tick: u64,
    num_samples: u64,
    aggregation_mode: AggregationMode,
) -> (u128, u32)

calculate_twap

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::calculate_twap

fn calculate_twap(
    self: @TContractState,
    data_type: DataType,
    aggregation_mode: AggregationMode,
    time: u64,
    start_time: u64,
) -> (u128, u32)

get_oracle_address

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::get_oracle_address

fn get_oracle_address(self: @TContractState) -> ContractAddress

get_options_data

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::get_options_data

fn get_options_data(self: @TContractState, instrument_name: felt252) -> OptionsFeedData

get_options_data_hash

Fully qualified path: pragma_lib::abi::ISummaryStatsABI::get_options_data_hash

fn get_options_data_hash(self: @TContractState, update_data: OptionsFeedData) -> felt252

IYieldCurveABI

Fully qualified path: pragma_lib::abi::IYieldCurveABI

trait IYieldCurveABI<TContractState>

Trait functions

get_yield_points

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_yield_points

fn get_yield_points(self: @TContractState, decimals: u32) -> Span<YieldPoint>

get_admin_address

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_admin_address

fn get_admin_address(self: @TContractState) -> ContractAddress

get_oracle_address

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_oracle_address

fn get_oracle_address(self: @TContractState) -> ContractAddress

get_future_spot_pragma_source_key

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_spot_pragma_source_key

fn get_future_spot_pragma_source_key(self: @TContractState) -> felt252

get_pair_id

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_pair_id

fn get_pair_id(self: @TContractState, idx: u64) -> felt252

get_pair_id_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_pair_id_is_active

fn get_pair_id_is_active(self: @TContractState, pair_id: felt252) -> bool

get_pair_ids

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_pair_ids

fn get_pair_ids(self: @TContractState) -> Span<felt252>

get_future_expiry_timestamp

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_expiry_timestamp

fn get_future_expiry_timestamp(self: @TContractState, pair_id: felt252, idx: u64) -> u64

get_future_expiry_timestamps

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_expiry_timestamps

fn get_future_expiry_timestamps(self: @TContractState, pair_id: felt252) -> Span<u64>

get_on_key

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_on_key

fn get_on_key(self: @TContractState, idx: u64) -> felt252

get_on_key_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_on_key_is_active

fn get_on_key_is_active(self: @TContractState, on_key: felt252) -> bool

get_on_keys

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_on_keys

fn get_on_keys(self: @TContractState) -> Span<felt252>

get_future_expiry_timestamp_status

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_expiry_timestamp_status

fn get_future_expiry_timestamp_status(
    self: @TContractState, pair_id: felt252, future_expiry_timestamp: u64,
) -> FutureKeyStatus

get_future_expiry_timestamp_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_expiry_timestamp_is_active

fn get_future_expiry_timestamp_is_active(
    self: @TContractState, pair_id: felt252, future_expiry_timestamp: u64,
) -> bool

get_future_expiry_timestamp_expiry

Fully qualified path: pragma_lib::abi::IYieldCurveABI::get_future_expiry_timestamp_expiry

fn get_future_expiry_timestamp_expiry(
    self: @TContractState, pair_id: felt252, future_expiry_timestamp: u64,
) -> u64

set_admin_address

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_admin_address

fn set_admin_address(ref self: TContractState, new_address: ContractAddress)

set_future_spot_pragma_source_key

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_future_spot_pragma_source_key

fn set_future_spot_pragma_source_key(ref self: TContractState, new_source_key: felt252)

set_oracle_address

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_oracle_address

fn set_oracle_address(ref self: TContractState, oracle_address: ContractAddress)

add_pair_id

Fully qualified path: pragma_lib::abi::IYieldCurveABI::add_pair_id

fn add_pair_id(ref self: TContractState, pair_id: felt252, is_active: bool)

set_pair_id_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_pair_id_is_active

fn set_pair_id_is_active(ref self: TContractState, pair_id: felt252, is_active: bool)

add_future_expiry_timestamp

Fully qualified path: pragma_lib::abi::IYieldCurveABI::add_future_expiry_timestamp

fn add_future_expiry_timestamp(
    ref self: TContractState,
    pair_id: felt252,
    future_expiry_timestamp: u64,
    is_active: bool,
    expiry_timestamp: u64,
)

set_future_expiry_timestamp_status

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_future_expiry_timestamp_status

fn set_future_expiry_timestamp_status(
    ref self: TContractState,
    pair_id: felt252,
    future_expiry_timestamp: u64,
    new_future_expiry_timestamp_status: FutureKeyStatus,
)

set_future_expiry_timestamp_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_future_expiry_timestamp_is_active

fn set_future_expiry_timestamp_is_active(
    ref self: TContractState, pair_id: felt252, future_expiry_timestamp: u64, new_is_active: bool,
)

add_on_key

Fully qualified path: pragma_lib::abi::IYieldCurveABI::add_on_key

fn add_on_key(ref self: TContractState, on_key: felt252, is_active: bool)

set_on_key_is_active

Fully qualified path: pragma_lib::abi::IYieldCurveABI::set_on_key_is_active

fn set_on_key_is_active(ref self: TContractState, on_key: felt252, is_active: bool)

IRandomness

Fully qualified path: pragma_lib::abi::IRandomness

trait IRandomness<TContractState>

Trait functions

update_status

Fully qualified path: pragma_lib::abi::IRandomness::update_status

fn update_status(
    ref self: TContractState,
    requestor_address: ContractAddress,
    request_id: u64,
    new_status: RequestStatus,
)

request_random

Fully qualified path: pragma_lib::abi::IRandomness::request_random

fn request_random(
    ref self: TContractState,
    seed: u64,
    callback_address: ContractAddress,
    callback_fee_limit: u128,
    publish_delay: u64,
    num_words: u64,
    calldata: Array<felt252>,
) -> u64

cancel_random_request

Fully qualified path: pragma_lib::abi::IRandomness::cancel_random_request

fn cancel_random_request(
    ref self: TContractState,
    request_id: u64,
    requestor_address: ContractAddress,
    seed: u64,
    minimum_block_number: u64,
    callback_address: ContractAddress,
    callback_fee_limit: u128,
    num_words: u64,
)

submit_random

Fully qualified path: pragma_lib::abi::IRandomness::submit_random

fn submit_random(
    ref self: TContractState,
    request_id: u64,
    requestor_address: ContractAddress,
    seed: u64,
    minimum_block_number: u64,
    callback_address: ContractAddress,
    callback_fee_limit: u128,
    callback_fee: u128,
    random_words: Span<felt252>,
    proof: Span<felt252>,
    calldata: Array<felt252>,
)

get_pending_requests

Fully qualified path: pragma_lib::abi::IRandomness::get_pending_requests

fn get_pending_requests(
    self: @TContractState, requestor_address: ContractAddress, offset: u64, max_len: u64,
) -> Span<felt252>

get_request_status

Fully qualified path: pragma_lib::abi::IRandomness::get_request_status

fn get_request_status(
    self: @TContractState, requestor_address: ContractAddress, request_id: u64,
) -> RequestStatus

requestor_current_index

Fully qualified path: pragma_lib::abi::IRandomness::requestor_current_index

fn requestor_current_index(self: @TContractState, requestor_address: ContractAddress) -> u64

get_public_key

Fully qualified path: pragma_lib::abi::IRandomness::get_public_key

fn get_public_key(self: @TContractState, requestor_address: ContractAddress) -> felt252

get_payment_token

Fully qualified path: pragma_lib::abi::IRandomness::get_payment_token

fn get_payment_token(self: @TContractState) -> ContractAddress

set_payment_token

Fully qualified path: pragma_lib::abi::IRandomness::set_payment_token

fn set_payment_token(ref self: TContractState, token_contract: ContractAddress)

upgrade

Fully qualified path: pragma_lib::abi::IRandomness::upgrade

fn upgrade(ref self: TContractState, impl_hash: ClassHash)

refund_operation

Fully qualified path: pragma_lib::abi::IRandomness::refund_operation

fn refund_operation(ref self: TContractState, caller_address: ContractAddress, request_id: u64)

get_total_fees

Fully qualified path: pragma_lib::abi::IRandomness::get_total_fees

fn get_total_fees(self: @TContractState, caller_address: ContractAddress, request_id: u64) -> u256

get_out_of_gas_requests

Fully qualified path: pragma_lib::abi::IRandomness::get_out_of_gas_requests

fn get_out_of_gas_requests(self: @TContractState, requestor_address: ContractAddress) -> Span<u64>

withdraw_funds

Fully qualified path: pragma_lib::abi::IRandomness::withdraw_funds

fn withdraw_funds(ref self: TContractState, receiver_address: ContractAddress)

get_contract_balance

Fully qualified path: pragma_lib::abi::IRandomness::get_contract_balance

fn get_contract_balance(self: @TContractState) -> u256

compute_premium_fee

Fully qualified path: pragma_lib::abi::IRandomness::compute_premium_fee

fn compute_premium_fee(self: @TContractState, caller_address: ContractAddress) -> u128

get_admin_address

Fully qualified path: pragma_lib::abi::IRandomness::get_admin_address

fn get_admin_address(self: @TContractState) -> ContractAddress

set_admin_address

Fully qualified path: pragma_lib::abi::IRandomness::set_admin_address

fn set_admin_address(ref self: TContractState, new_admin_address: ContractAddress)

IOptimisticOracle

Fully qualified path: pragma_lib::abi::IOptimisticOracle

pub trait IOptimisticOracle<TContractState>

Trait functions

assert_truth_with_defaults

Fully qualified path: pragma_lib::abi::IOptimisticOracle::assert_truth_with_defaults

fn assert_truth_with_defaults(
    ref self: TContractState, claim: ByteArray, asserter: ContractAddress,
) -> felt252

assert_truth

Fully qualified path: pragma_lib::abi::IOptimisticOracle::assert_truth

fn assert_truth(
    ref self: TContractState,
    claim: ByteArray,
    asserter: ContractAddress,
    callback_recipient: ContractAddress,
    escalation_manager: ContractAddress,
    liveness: u64,
    currency: ERC20ABIDispatcher,
    bond: u256,
    identifier: felt252,
    domain_id: u256,
) -> felt252

dispute_assertion

Fully qualified path: pragma_lib::abi::IOptimisticOracle::dispute_assertion

fn dispute_assertion(ref self: TContractState, assertion_id: felt252, disputer: ContractAddress)

settle_assertion

Fully qualified path: pragma_lib::abi::IOptimisticOracle::settle_assertion

fn settle_assertion(ref self: TContractState, assertion_id: felt252)

get_minimum_bond

Fully qualified path: pragma_lib::abi::IOptimisticOracle::get_minimum_bond

fn get_minimum_bond(self: @TContractState, currency: ContractAddress) -> u256

stamp_assertion

Fully qualified path: pragma_lib::abi::IOptimisticOracle::stamp_assertion

fn stamp_assertion(self: @TContractState, assertion_id: felt252) -> ByteArray

default_identifier

Fully qualified path: pragma_lib::abi::IOptimisticOracle::default_identifier

fn default_identifier(self: @TContractState) -> felt252

get_assertion

Fully qualified path: pragma_lib::abi::IOptimisticOracle::get_assertion

fn get_assertion(self: @TContractState, assertion_id: felt252) -> Assertion

sync_params

Fully qualified path: pragma_lib::abi::IOptimisticOracle::sync_params

fn sync_params(ref self: TContractState, identifier: felt252, currency: ContractAddress)

settle_and_get_assertion_result

Fully qualified path: pragma_lib::abi::IOptimisticOracle::settle_and_get_assertion_result

fn settle_and_get_assertion_result(ref self: TContractState, assertion_id: felt252) -> bool

get_assertion_result

Fully qualified path: pragma_lib::abi::IOptimisticOracle::get_assertion_result

fn get_assertion_result(self: @TContractState, assertion_id: felt252) -> bool

set_admin_properties

Fully qualified path: pragma_lib::abi::IOptimisticOracle::set_admin_properties

fn set_admin_properties(
    ref self: TContractState,
    default_currency: ContractAddress,
    default_liveness: u64,
    burned_bond_percentage: u256,
)

UnsafeNewContractStateTraitForIPragmaABIForwardImpl

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIPragmaABIForwardImpl

trait UnsafeNewContractStateTraitForIPragmaABIForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIPragmaABIForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

UnsafeNewContractStateTraitForISummaryStatsABIForwardImpl

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForISummaryStatsABIForwardImpl

trait UnsafeNewContractStateTraitForISummaryStatsABIForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForISummaryStatsABIForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

UnsafeNewContractStateTraitForIYieldCurveABIForwardImpl

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIYieldCurveABIForwardImpl

trait UnsafeNewContractStateTraitForIYieldCurveABIForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIYieldCurveABIForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

UnsafeNewContractStateTraitForIRandomnessForwardImpl

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIRandomnessForwardImpl

trait UnsafeNewContractStateTraitForIRandomnessForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIRandomnessForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

UnsafeNewContractStateTraitForIOptimisticOracleForwardImpl

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIOptimisticOracleForwardImpl

pub trait UnsafeNewContractStateTraitForIOptimisticOracleForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: pragma_lib::abi::UnsafeNewContractStateTraitForIOptimisticOracleForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

Impls

Impls

IPragmaABIDispatcherStore

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore

impl IPragmaABIDispatcherStore of Store<IPragmaABIDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IPragmaABIDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IPragmaABIDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IPragmaABIDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IPragmaABIDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcherStore::size

fn size() -> u8

IPragmaABILibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore

impl IPragmaABILibraryDispatcherStore of Store<IPragmaABILibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IPragmaABILibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IPragmaABILibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IPragmaABILibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IPragmaABILibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcherStore::size

fn size() -> u8

IPragmaABISafeLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore

impl IPragmaABISafeLibraryDispatcherStore of Store<IPragmaABISafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IPragmaABISafeLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IPragmaABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IPragmaABISafeLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IPragmaABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcherStore::size

fn size() -> u8

IPragmaABISafeDispatcherStore

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore

impl IPragmaABISafeDispatcherStore of Store<IPragmaABISafeDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IPragmaABISafeDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IPragmaABISafeDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IPragmaABISafeDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IPragmaABISafeDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcherStore::size

fn size() -> u8

ISummaryStatsABIDispatcherStore

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore

impl ISummaryStatsABIDispatcherStore of Store<ISummaryStatsABIDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<ISummaryStatsABIDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: ISummaryStatsABIDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<ISummaryStatsABIDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: ISummaryStatsABIDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcherStore::size

fn size() -> u8

ISummaryStatsABILibraryDispatcherStore

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore

impl ISummaryStatsABILibraryDispatcherStore of Store<ISummaryStatsABILibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<ISummaryStatsABILibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: ISummaryStatsABILibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<ISummaryStatsABILibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: ISummaryStatsABILibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcherStore::size

fn size() -> u8

ISummaryStatsABISafeLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore

impl ISummaryStatsABISafeLibraryDispatcherStore of Store<ISummaryStatsABISafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<ISummaryStatsABISafeLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: ISummaryStatsABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<ISummaryStatsABISafeLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: ISummaryStatsABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcherStore::size

fn size() -> u8

ISummaryStatsABISafeDispatcherStore

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore

impl ISummaryStatsABISafeDispatcherStore of Store<ISummaryStatsABISafeDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<ISummaryStatsABISafeDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: ISummaryStatsABISafeDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<ISummaryStatsABISafeDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: ISummaryStatsABISafeDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcherStore::size

fn size() -> u8

IYieldCurveABIDispatcherStore

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore

impl IYieldCurveABIDispatcherStore of Store<IYieldCurveABIDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IYieldCurveABIDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IYieldCurveABIDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IYieldCurveABIDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IYieldCurveABIDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcherStore::size

fn size() -> u8

IYieldCurveABILibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore

impl IYieldCurveABILibraryDispatcherStore of Store<IYieldCurveABILibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IYieldCurveABILibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IYieldCurveABILibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IYieldCurveABILibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IYieldCurveABILibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcherStore::size

fn size() -> u8

IYieldCurveABISafeLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore

impl IYieldCurveABISafeLibraryDispatcherStore of Store<IYieldCurveABISafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IYieldCurveABISafeLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IYieldCurveABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IYieldCurveABISafeLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IYieldCurveABISafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcherStore::size

fn size() -> u8

IYieldCurveABISafeDispatcherStore

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore

impl IYieldCurveABISafeDispatcherStore of Store<IYieldCurveABISafeDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IYieldCurveABISafeDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IYieldCurveABISafeDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IYieldCurveABISafeDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IYieldCurveABISafeDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcherStore::size

fn size() -> u8

IRandomnessDispatcherStore

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore

impl IRandomnessDispatcherStore of Store<IRandomnessDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IRandomnessDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IRandomnessDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IRandomnessDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IRandomnessDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IRandomnessDispatcherStore::size

fn size() -> u8

IRandomnessLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore

impl IRandomnessLibraryDispatcherStore of Store<IRandomnessLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IRandomnessLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IRandomnessLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IRandomnessLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IRandomnessLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcherStore::size

fn size() -> u8

IRandomnessSafeLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore

impl IRandomnessSafeLibraryDispatcherStore of Store<IRandomnessSafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IRandomnessSafeLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IRandomnessSafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IRandomnessSafeLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IRandomnessSafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcherStore::size

fn size() -> u8

IRandomnessSafeDispatcherStore

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore

impl IRandomnessSafeDispatcherStore of Store<IRandomnessSafeDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IRandomnessSafeDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IRandomnessSafeDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IRandomnessSafeDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IRandomnessSafeDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcherStore::size

fn size() -> u8

IOptimisticOracleDispatcherStore

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore

impl IOptimisticOracleDispatcherStore of Store<IOptimisticOracleDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IOptimisticOracleDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IOptimisticOracleDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IOptimisticOracleDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: IOptimisticOracleDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IOptimisticOracleDispatcherStore::size

fn size() -> u8

IOptimisticOracleLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore

impl IOptimisticOracleLibraryDispatcherStore of Store<IOptimisticOracleLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IOptimisticOracleLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IOptimisticOracleLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IOptimisticOracleLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IOptimisticOracleLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IOptimisticOracleLibraryDispatcherStore::size

fn size() -> u8

IOptimisticOracleSafeLibraryDispatcherStore

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore

impl IOptimisticOracleSafeLibraryDispatcherStore of Store<IOptimisticOracleSafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IOptimisticOracleSafeLibraryDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IOptimisticOracleSafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IOptimisticOracleSafeLibraryDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IOptimisticOracleSafeLibraryDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeLibraryDispatcherStore::size

fn size() -> u8

IOptimisticOracleSafeDispatcherStore

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore

impl IOptimisticOracleSafeDispatcherStore of Store<IOptimisticOracleSafeDispatcher>;

Impl functions

read

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<IOptimisticOracleSafeDispatcher, Array<felt252>>

write

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: IOptimisticOracleSafeDispatcher,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<IOptimisticOracleSafeDispatcher, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore::write_at_offset

fn write_at_offset(
    address_domain: u32,
    base: StorageBaseAddress,
    offset: u8,
    value: IOptimisticOracleSafeDispatcher,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::abi::IOptimisticOracleSafeDispatcherStore::size

fn size() -> u8

types

Fully qualified path: pragma_lib::types

Structs

Enums

Impls

Structs

Structs

YieldPoint

Fully qualified path: pragma_lib::types::YieldPoint

[derive(Serde, Drop, Copy, starknet::Store)]
struct YieldPoint {
    expiry_timestamp: u64,
    capture_timestamp: u64,
    rate: u128,
    source: felt252,
}

Members

expiry_timestamp

Fully qualified path: pragma_lib::types::YieldPoint::expiry_timestamp

expiry_timestamp: u64

capture_timestamp

Fully qualified path: pragma_lib::types::YieldPoint::capture_timestamp

capture_timestamp: u64

rate

Fully qualified path: pragma_lib::types::YieldPoint::rate

rate: u128

source

Fully qualified path: pragma_lib::types::YieldPoint::source

source: felt252

FutureKeyStatus

Fully qualified path: pragma_lib::types::FutureKeyStatus

[derive(Serde, Drop, Copy, starknet::Store)]
struct FutureKeyStatus {
    is_active: bool,
    expiry_timestamp: u64,
}

Members

is_active

Fully qualified path: pragma_lib::types::FutureKeyStatus::is_active

is_active: bool

expiry_timestamp

Fully qualified path: pragma_lib::types::FutureKeyStatus::expiry_timestamp

expiry_timestamp: u64

BaseEntry

Fully qualified path: pragma_lib::types::BaseEntry

[derive(Copy, Drop, Serde, PartialEq, starknet::Store)]
struct BaseEntry {
    timestamp: u64,
    source: felt252,
    publisher: felt252,
}

Members

timestamp

Fully qualified path: pragma_lib::types::BaseEntry::timestamp

timestamp: u64

source

Fully qualified path: pragma_lib::types::BaseEntry::source

source: felt252

publisher

Fully qualified path: pragma_lib::types::BaseEntry::publisher

publisher: felt252

GenericEntryStorage

Fully qualified path: pragma_lib::types::GenericEntryStorage

[derive(Serde, Drop, Copy)]
struct GenericEntryStorage {
    timestamp__value: u256,
}

Members

timestamp__value

Fully qualified path: pragma_lib::types::GenericEntryStorage::timestamp__value

timestamp__value: u256

SpotEntry

Fully qualified path: pragma_lib::types::SpotEntry

#[derive(Copy, Drop, Serde)]
struct SpotEntry {
    base: BaseEntry,
    price: u128,
    pair_id: felt252,
    volume: u128,
}

Members

base

Fully qualified path: pragma_lib::types::SpotEntry::base

base: BaseEntry

price

Fully qualified path: pragma_lib::types::SpotEntry::price

price: u128

pair_id

Fully qualified path: pragma_lib::types::SpotEntry::pair_id

pair_id: felt252

volume

Fully qualified path: pragma_lib::types::SpotEntry::volume

volume: u128

GenericEntry

Fully qualified path: pragma_lib::types::GenericEntry

#[derive(Copy, Drop, Serde)]
struct GenericEntry {
    base: BaseEntry,
    key: felt252,
    value: u128,
}

Members

base

Fully qualified path: pragma_lib::types::GenericEntry::base

base: BaseEntry

key

Fully qualified path: pragma_lib::types::GenericEntry::key

key: felt252

value

Fully qualified path: pragma_lib::types::GenericEntry::value

value: u128

FutureEntry

Fully qualified path: pragma_lib::types::FutureEntry

#[derive(Copy, Drop, PartialEq, Serde)]
struct FutureEntry {
    base: BaseEntry,
    price: u128,
    pair_id: felt252,
    volume: u128,
    expiration_timestamp: u64,
}

Members

base

Fully qualified path: pragma_lib::types::FutureEntry::base

base: BaseEntry

price

Fully qualified path: pragma_lib::types::FutureEntry::price

price: u128

pair_id

Fully qualified path: pragma_lib::types::FutureEntry::pair_id

pair_id: felt252

volume

Fully qualified path: pragma_lib::types::FutureEntry::volume

volume: u128

expiration_timestamp

Fully qualified path: pragma_lib::types::FutureEntry::expiration_timestamp

expiration_timestamp: u64

EntryStorage

Fully qualified path: pragma_lib::types::EntryStorage

[derive(Serde, Drop, Copy)]
struct EntryStorage {
    timestamp: u64,
    volume: u128,
    price: u128,
}

Members

timestamp

Fully qualified path: pragma_lib::types::EntryStorage::timestamp

timestamp: u64

volume

Fully qualified path: pragma_lib::types::EntryStorage::volume

volume: u128

price

Fully qualified path: pragma_lib::types::EntryStorage::price

price: u128

OptionsFeedData

Fully qualified path: pragma_lib::types::OptionsFeedData

[derive(Drop, Serde, starknet::Store, Copy, Hash, PartialEq, Debug)]
struct OptionsFeedData {
    instrument_name: felt252,
    base_currency_id: felt252,
    current_timestamp: u64,
    mark_price: u128,
}

Members

instrument_name

Fully qualified path: pragma_lib::types::OptionsFeedData::instrument_name

instrument_name: felt252

base_currency_id

Fully qualified path: pragma_lib::types::OptionsFeedData::base_currency_id

base_currency_id: felt252

current_timestamp

Fully qualified path: pragma_lib::types::OptionsFeedData::current_timestamp

current_timestamp: u64

mark_price

Fully qualified path: pragma_lib::types::OptionsFeedData::mark_price

mark_price: u128

Pair

Fully qualified path: pragma_lib::types::Pair

[derive(Serde, Drop, Copy, starknet::Store)]
struct Pair {
    id: felt252,
    quote_currency_id: felt252,
    base_currency_id: felt252,
}

Members

id

Fully qualified path: pragma_lib::types::Pair::id

id: felt252

quote_currency_id

Fully qualified path: pragma_lib::types::Pair::quote_currency_id

quote_currency_id: felt252

base_currency_id

Fully qualified path: pragma_lib::types::Pair::base_currency_id

base_currency_id: felt252

Currency

Fully qualified path: pragma_lib::types::Currency

[derive(Serde, Drop, Copy, starknet::Store)]
struct Currency {
    id: felt252,
    decimals: u32,
    is_abstract_currency: bool,
    starknet_address: ContractAddress,
    ethereum_address: ContractAddress,
}

Members

id

Fully qualified path: pragma_lib::types::Currency::id

id: felt252

decimals

Fully qualified path: pragma_lib::types::Currency::decimals

decimals: u32

is_abstract_currency

Fully qualified path: pragma_lib::types::Currency::is_abstract_currency

is_abstract_currency: bool

starknet_address

Fully qualified path: pragma_lib::types::Currency::starknet_address

starknet_address: ContractAddress

ethereum_address

Fully qualified path: pragma_lib::types::Currency::ethereum_address

ethereum_address: ContractAddress

Checkpoint

Fully qualified path: pragma_lib::types::Checkpoint

#[derive(Serde, Drop)]
struct Checkpoint {
    timestamp: u64,
    value: u128,
    aggregation_mode: AggregationMode,
    num_sources_aggregated: u32,
}

Members

timestamp

Fully qualified path: pragma_lib::types::Checkpoint::timestamp

timestamp: u64

value

Fully qualified path: pragma_lib::types::Checkpoint::value

value: u128

aggregation_mode

Fully qualified path: pragma_lib::types::Checkpoint::aggregation_mode

aggregation_mode: AggregationMode

num_sources_aggregated

Fully qualified path: pragma_lib::types::Checkpoint::num_sources_aggregated

num_sources_aggregated: u32

FetchCheckpoint

Fully qualified path: pragma_lib::types::FetchCheckpoint

[derive(Serde, Drop, Copy, starknet::Store)]
struct FetchCheckpoint {
    pair_id: felt252,
    type_of: felt252,
    index: u64,
    expiration_timestamp: u64,
    aggregation_mode: u8,
}

Members

pair_id

Fully qualified path: pragma_lib::types::FetchCheckpoint::pair_id

pair_id: felt252

type_of

Fully qualified path: pragma_lib::types::FetchCheckpoint::type_of

type_of: felt252

index

Fully qualified path: pragma_lib::types::FetchCheckpoint::index

index: u64

expiration_timestamp

Fully qualified path: pragma_lib::types::FetchCheckpoint::expiration_timestamp

expiration_timestamp: u64

aggregation_mode

Fully qualified path: pragma_lib::types::FetchCheckpoint::aggregation_mode

aggregation_mode: u8

PragmaPricesResponse

Fully qualified path: pragma_lib::types::PragmaPricesResponse

[derive(Serde, Drop, Copy)]
struct PragmaPricesResponse {
    price: u128,
    decimals: u32,
    last_updated_timestamp: u64,
    num_sources_aggregated: u32,
    expiration_timestamp: Option<u64>,
}

Members

price

Fully qualified path: pragma_lib::types::PragmaPricesResponse::price

price: u128

decimals

Fully qualified path: pragma_lib::types::PragmaPricesResponse::decimals

decimals: u32

last_updated_timestamp

Fully qualified path: pragma_lib::types::PragmaPricesResponse::last_updated_timestamp

last_updated_timestamp: u64

num_sources_aggregated

Fully qualified path: pragma_lib::types::PragmaPricesResponse::num_sources_aggregated

num_sources_aggregated: u32

expiration_timestamp

Fully qualified path: pragma_lib::types::PragmaPricesResponse::expiration_timestamp

expiration_timestamp: Option<u64>

EscalationManagerSettings

Fully qualified path: pragma_lib::types::EscalationManagerSettings

[derive(starknet::Store, Drop, Serde, Copy)]
pub struct EscalationManagerSettings {
    pub arbitrate_via_escalation_manager: bool,
    pub discard_oracle: bool,
    pub validate_disputers: bool,
    pub asserting_caller: ContractAddress,
    pub escalation_manager: ContractAddress,
}

Members

arbitrate_via_escalation_manager

Fully qualified path: pragma_lib::types::EscalationManagerSettings::arbitrate_via_escalation_manager

pub arbitrate_via_escalation_manager: bool

discard_oracle

Fully qualified path: pragma_lib::types::EscalationManagerSettings::discard_oracle

pub discard_oracle: bool

validate_disputers

Fully qualified path: pragma_lib::types::EscalationManagerSettings::validate_disputers

pub validate_disputers: bool

asserting_caller

Fully qualified path: pragma_lib::types::EscalationManagerSettings::asserting_caller

pub asserting_caller: ContractAddress

escalation_manager

Fully qualified path: pragma_lib::types::EscalationManagerSettings::escalation_manager

pub escalation_manager: ContractAddress

Assertion

Fully qualified path: pragma_lib::types::Assertion

#[derive(starknet::Store, Drop, Serde, Copy)]
pub struct Assertion {
    pub escalation_manager_settings: EscalationManagerSettings,
    pub asserter: ContractAddress,
    pub assertion_time: u64,
    pub settled: bool,
    pub currency: ERC20ABIDispatcher,
    pub expiration_time: u64,
    pub settlement_resolution: bool,
    pub domain_id: u256,
    pub identifier: felt252,
    pub bond: u256,
    pub callback_recipient: ContractAddress,
    pub disputer: ContractAddress,
}

Members

escalation_manager_settings

Fully qualified path: pragma_lib::types::Assertion::escalation_manager_settings

pub escalation_manager_settings: EscalationManagerSettings

asserter

Fully qualified path: pragma_lib::types::Assertion::asserter

pub asserter: ContractAddress

assertion_time

Fully qualified path: pragma_lib::types::Assertion::assertion_time

pub assertion_time: u64

settled

Fully qualified path: pragma_lib::types::Assertion::settled

pub settled: bool

currency

Fully qualified path: pragma_lib::types::Assertion::currency

pub currency: ERC20ABIDispatcher

expiration_time

Fully qualified path: pragma_lib::types::Assertion::expiration_time

pub expiration_time: u64

settlement_resolution

Fully qualified path: pragma_lib::types::Assertion::settlement_resolution

pub settlement_resolution: bool

domain_id

Fully qualified path: pragma_lib::types::Assertion::domain_id

pub domain_id: u256

identifier

Fully qualified path: pragma_lib::types::Assertion::identifier

pub identifier: felt252

bond

Fully qualified path: pragma_lib::types::Assertion::bond

pub bond: u256

callback_recipient

Fully qualified path: pragma_lib::types::Assertion::callback_recipient

pub callback_recipient: ContractAddress

disputer

Fully qualified path: pragma_lib::types::Assertion::disputer

pub disputer: ContractAddress

Enums

Enums

RequestStatus

Fully qualified path: pragma_lib::types::RequestStatus

enum RequestStatus {
    UNINITIALIZED,
    RECEIVED,
    FULFILLED,
    CANCELLED,
    OUT_OF_GAS,
    REFUNDED,
}

Variants

UNINITIALIZED

Fully qualified path: pragma_lib::types::RequestStatus::UNINITIALIZED

UNINITIALIZED

RECEIVED

Fully qualified path: pragma_lib::types::RequestStatus::RECEIVED

RECEIVED

FULFILLED

Fully qualified path: pragma_lib::types::RequestStatus::FULFILLED

FULFILLED

CANCELLED

Fully qualified path: pragma_lib::types::RequestStatus::CANCELLED

CANCELLED

OUT_OF_GAS

Fully qualified path: pragma_lib::types::RequestStatus::OUT_OF_GAS

OUT_OF_GAS

REFUNDED

Fully qualified path: pragma_lib::types::RequestStatus::REFUNDED

REFUNDED

DataType

Data Types The value is the pair_id of the data For future option, pair_id and expiration timestamp

• Spot - Spot price
• Future - Future price
• Option - Option price

Fully qualified path: pragma_lib::types::DataType

enum DataType {
    SpotEntry: felt252,
    FutureEntry: (felt252, u64),
    GenericEntry: felt252,
}

Variants

SpotEntry

Fully qualified path: pragma_lib::types::DataType::SpotEntry

SpotEntry: felt252

FutureEntry

Fully qualified path: pragma_lib::types::DataType::FutureEntry

FutureEntry: (felt252, u64)

GenericEntry

Fully qualified path: pragma_lib::types::DataType::GenericEntry

GenericEntry: felt252

PossibleEntryStorage

Fully qualified path: pragma_lib::types::PossibleEntryStorage

enum PossibleEntryStorage {
    Spot: u256,
    Future: u256,
}

Variants

Spot

Fully qualified path: pragma_lib::types::PossibleEntryStorage::Spot

Spot: u256

Future

Fully qualified path: pragma_lib::types::PossibleEntryStorage::Future

Future: u256

SimpleDataType

Fully qualified path: pragma_lib::types::SimpleDataType

enum SimpleDataType {
    SpotEntry,
    FutureEntry,
}

Variants

SpotEntry

Fully qualified path: pragma_lib::types::SimpleDataType::SpotEntry

SpotEntry

FutureEntry

Fully qualified path: pragma_lib::types::SimpleDataType::FutureEntry

FutureEntry

PossibleEntries

Fully qualified path: pragma_lib::types::PossibleEntries

enum PossibleEntries {
    Spot: SpotEntry,
    Future: FutureEntry,
    Generic: GenericEntry,
}

Variants

Spot

Fully qualified path: pragma_lib::types::PossibleEntries::Spot

Spot: SpotEntry

Future

Fully qualified path: pragma_lib::types::PossibleEntries::Future

Future: FutureEntry

Generic

Fully qualified path: pragma_lib::types::PossibleEntries::Generic

Generic: GenericEntry

ArrayEntry

Fully qualified path: pragma_lib::types::ArrayEntry

enum ArrayEntry {
    SpotEntry: Array<SpotEntry>,
    FutureEntry: Array<FutureEntry>,
    GenericEntry: Array<GenericEntry>,
}

Variants

SpotEntry

Fully qualified path: pragma_lib::types::ArrayEntry::SpotEntry

SpotEntry: Array<SpotEntry>

FutureEntry

Fully qualified path: pragma_lib::types::ArrayEntry::FutureEntry

FutureEntry: Array<FutureEntry>

GenericEntry

Fully qualified path: pragma_lib::types::ArrayEntry::GenericEntry

GenericEntry: Array<GenericEntry>

AggregationMode

Fully qualified path: pragma_lib::types::AggregationMode

enum AggregationMode {
    Median,
    Mean,
    ConversionRate,
    Error,
}

Variants

Median

Fully qualified path: pragma_lib::types::AggregationMode::Median

Median

Mean

Fully qualified path: pragma_lib::types::AggregationMode::Mean

Mean

ConversionRate

Fully qualified path: pragma_lib::types::AggregationMode::ConversionRate

ConversionRate

Error

Fully qualified path: pragma_lib::types::AggregationMode::Error

Error

Impls

Impls

RequestStatusSerde

Fully qualified path: pragma_lib::types::RequestStatusSerde

impl RequestStatusSerde of Serde<RequestStatus>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::RequestStatusSerde::serialize

fn serialize(self: @RequestStatus, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::RequestStatusSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<RequestStatus>

RequestStatusDrop

Fully qualified path: pragma_lib::types::RequestStatusDrop

impl RequestStatusDrop of Drop<RequestStatus>;

RequestStatusCopy

Fully qualified path: pragma_lib::types::RequestStatusCopy

impl RequestStatusCopy of Copy<RequestStatus>;

RequestStatusPartialEq

Fully qualified path: pragma_lib::types::RequestStatusPartialEq

impl RequestStatusPartialEq of PartialEq<RequestStatus>;

Impl functions

eq

Fully qualified path: pragma_lib::types::RequestStatusPartialEq::eq

fn eq(lhs: @RequestStatus, rhs: @RequestStatus) -> bool

RequestStatusStore

Fully qualified path: pragma_lib::types::RequestStatusStore

impl RequestStatusStore of Store<RequestStatus>;

Impl functions

read

Fully qualified path: pragma_lib::types::RequestStatusStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<RequestStatus, Array<felt252>>

write

Fully qualified path: pragma_lib::types::RequestStatusStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: RequestStatus,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::RequestStatusStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<RequestStatus, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::RequestStatusStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: RequestStatus,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::RequestStatusStore::size

fn size() -> u8

YieldPointSerde

Fully qualified path: pragma_lib::types::YieldPointSerde

impl YieldPointSerde of Serde<YieldPoint>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::YieldPointSerde::serialize

fn serialize(self: @YieldPoint, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::YieldPointSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<YieldPoint>

YieldPointDrop

Fully qualified path: pragma_lib::types::YieldPointDrop

impl YieldPointDrop of Drop<YieldPoint>;

YieldPointCopy

Fully qualified path: pragma_lib::types::YieldPointCopy

impl YieldPointCopy of Copy<YieldPoint>;

YieldPointStore

Fully qualified path: pragma_lib::types::YieldPointStore

impl YieldPointStore of Store<YieldPoint>;

Impl functions

read

Fully qualified path: pragma_lib::types::YieldPointStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<YieldPoint, Array<felt252>>

write

Fully qualified path: pragma_lib::types::YieldPointStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: YieldPoint,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::YieldPointStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<YieldPoint, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::YieldPointStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: YieldPoint,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::YieldPointStore::size

fn size() -> u8

FutureKeyStatusSerde

Fully qualified path: pragma_lib::types::FutureKeyStatusSerde

impl FutureKeyStatusSerde of Serde<FutureKeyStatus>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::FutureKeyStatusSerde::serialize

fn serialize(self: @FutureKeyStatus, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::FutureKeyStatusSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<FutureKeyStatus>

FutureKeyStatusDrop

Fully qualified path: pragma_lib::types::FutureKeyStatusDrop

impl FutureKeyStatusDrop of Drop<FutureKeyStatus>;

FutureKeyStatusCopy

Fully qualified path: pragma_lib::types::FutureKeyStatusCopy

impl FutureKeyStatusCopy of Copy<FutureKeyStatus>;

FutureKeyStatusStore

Fully qualified path: pragma_lib::types::FutureKeyStatusStore

impl FutureKeyStatusStore of Store<FutureKeyStatus>;

Impl functions

read

Fully qualified path: pragma_lib::types::FutureKeyStatusStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<FutureKeyStatus, Array<felt252>>

write

Fully qualified path: pragma_lib::types::FutureKeyStatusStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: FutureKeyStatus,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::FutureKeyStatusStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<FutureKeyStatus, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::FutureKeyStatusStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: FutureKeyStatus,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::FutureKeyStatusStore::size

fn size() -> u8

BaseEntryCopy

Fully qualified path: pragma_lib::types::BaseEntryCopy

impl BaseEntryCopy of Copy<BaseEntry>;

BaseEntryDrop

Fully qualified path: pragma_lib::types::BaseEntryDrop

impl BaseEntryDrop of Drop<BaseEntry>;

BaseEntrySerde

Fully qualified path: pragma_lib::types::BaseEntrySerde

impl BaseEntrySerde of Serde<BaseEntry>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::BaseEntrySerde::serialize

fn serialize(self: @BaseEntry, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::BaseEntrySerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<BaseEntry>

BaseEntryPartialEq

Fully qualified path: pragma_lib::types::BaseEntryPartialEq

impl BaseEntryPartialEq of PartialEq<BaseEntry>;

Impl functions

eq

Fully qualified path: pragma_lib::types::BaseEntryPartialEq::eq

fn eq(lhs: @BaseEntry, rhs: @BaseEntry) -> bool

BaseEntryStore

Fully qualified path: pragma_lib::types::BaseEntryStore

impl BaseEntryStore of Store<BaseEntry>;

Impl functions

read

Fully qualified path: pragma_lib::types::BaseEntryStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<BaseEntry, Array<felt252>>

write

Fully qualified path: pragma_lib::types::BaseEntryStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: BaseEntry,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::BaseEntryStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<BaseEntry, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::BaseEntryStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: BaseEntry,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::BaseEntryStore::size

fn size() -> u8

GenericEntryStorageSerde

Fully qualified path: pragma_lib::types::GenericEntryStorageSerde

impl GenericEntryStorageSerde of Serde<GenericEntryStorage>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::GenericEntryStorageSerde::serialize

fn serialize(self: @GenericEntryStorage, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::GenericEntryStorageSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<GenericEntryStorage>

GenericEntryStorageDrop

Fully qualified path: pragma_lib::types::GenericEntryStorageDrop

impl GenericEntryStorageDrop of Drop<GenericEntryStorage>;

GenericEntryStorageCopy

Fully qualified path: pragma_lib::types::GenericEntryStorageCopy

impl GenericEntryStorageCopy of Copy<GenericEntryStorage>;

SpotEntryCopy

Fully qualified path: pragma_lib::types::SpotEntryCopy

impl SpotEntryCopy of Copy<SpotEntry>;

SpotEntryDrop

Fully qualified path: pragma_lib::types::SpotEntryDrop

impl SpotEntryDrop of Drop<SpotEntry>;

SpotEntrySerde

Fully qualified path: pragma_lib::types::SpotEntrySerde

impl SpotEntrySerde of Serde<SpotEntry>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::SpotEntrySerde::serialize

fn serialize(self: @SpotEntry, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::SpotEntrySerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<SpotEntry>

GenericEntryCopy

Fully qualified path: pragma_lib::types::GenericEntryCopy

impl GenericEntryCopy of Copy<GenericEntry>;

GenericEntryDrop

Fully qualified path: pragma_lib::types::GenericEntryDrop

impl GenericEntryDrop of Drop<GenericEntry>;

GenericEntrySerde

Fully qualified path: pragma_lib::types::GenericEntrySerde

impl GenericEntrySerde of Serde<GenericEntry>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::GenericEntrySerde::serialize

fn serialize(self: @GenericEntry, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::GenericEntrySerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<GenericEntry>

FutureEntryCopy

Fully qualified path: pragma_lib::types::FutureEntryCopy

impl FutureEntryCopy of Copy<FutureEntry>;

FutureEntryDrop

Fully qualified path: pragma_lib::types::FutureEntryDrop

impl FutureEntryDrop of Drop<FutureEntry>;

FutureEntryPartialEq

Fully qualified path: pragma_lib::types::FutureEntryPartialEq

impl FutureEntryPartialEq of PartialEq<FutureEntry>;

Impl functions

eq

Fully qualified path: pragma_lib::types::FutureEntryPartialEq::eq

fn eq(lhs: @FutureEntry, rhs: @FutureEntry) -> bool

FutureEntrySerde

Fully qualified path: pragma_lib::types::FutureEntrySerde

impl FutureEntrySerde of Serde<FutureEntry>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::FutureEntrySerde::serialize

fn serialize(self: @FutureEntry, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::FutureEntrySerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<FutureEntry>

EntryStorageSerde

Fully qualified path: pragma_lib::types::EntryStorageSerde

impl EntryStorageSerde of Serde<EntryStorage>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::EntryStorageSerde::serialize

fn serialize(self: @EntryStorage, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::EntryStorageSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<EntryStorage>

EntryStorageDrop

Fully qualified path: pragma_lib::types::EntryStorageDrop

impl EntryStorageDrop of Drop<EntryStorage>;

EntryStorageCopy

Fully qualified path: pragma_lib::types::EntryStorageCopy

impl EntryStorageCopy of Copy<EntryStorage>;

OptionsFeedDataDrop

Fully qualified path: pragma_lib::types::OptionsFeedDataDrop

impl OptionsFeedDataDrop of Drop<OptionsFeedData>;

OptionsFeedDataSerde

Fully qualified path: pragma_lib::types::OptionsFeedDataSerde

impl OptionsFeedDataSerde of Serde<OptionsFeedData>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::OptionsFeedDataSerde::serialize

fn serialize(self: @OptionsFeedData, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::OptionsFeedDataSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<OptionsFeedData>

OptionsFeedDataCopy

Fully qualified path: pragma_lib::types::OptionsFeedDataCopy

impl OptionsFeedDataCopy of Copy<OptionsFeedData>;

OptionsFeedDataHash

Fully qualified path: pragma_lib::types::OptionsFeedDataHash

impl OptionsFeedDataHash<
    __State, impl __SHashState: HashStateTrait<__State>, +core::traits::Drop<__State>,
> of Hash<OptionsFeedData, __State, __SHashState>;

Impl functions

update_state

Fully qualified path: pragma_lib::types::OptionsFeedDataHash::update_state

fn update_state(state: __State, value: OptionsFeedData) -> __State

OptionsFeedDataPartialEq

Fully qualified path: pragma_lib::types::OptionsFeedDataPartialEq

impl OptionsFeedDataPartialEq of PartialEq<OptionsFeedData>;

Impl functions

eq

Fully qualified path: pragma_lib::types::OptionsFeedDataPartialEq::eq

fn eq(lhs: @OptionsFeedData, rhs: @OptionsFeedData) -> bool

OptionsFeedDataDebug

Fully qualified path: pragma_lib::types::OptionsFeedDataDebug

impl OptionsFeedDataDebug of Debug<OptionsFeedData>;

Impl functions

fmt

Fully qualified path: pragma_lib::types::OptionsFeedDataDebug::fmt

fn fmt(self: @OptionsFeedData, ref f: Formatter) -> Result<(), Error>

OptionsFeedDataStore

Fully qualified path: pragma_lib::types::OptionsFeedDataStore

impl OptionsFeedDataStore of Store<OptionsFeedData>;

Impl functions

read

Fully qualified path: pragma_lib::types::OptionsFeedDataStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<OptionsFeedData, Array<felt252>>

write

Fully qualified path: pragma_lib::types::OptionsFeedDataStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: OptionsFeedData,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::OptionsFeedDataStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<OptionsFeedData, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::OptionsFeedDataStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: OptionsFeedData,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::OptionsFeedDataStore::size

fn size() -> u8

DataTypeDrop

Fully qualified path: pragma_lib::types::DataTypeDrop

impl DataTypeDrop of Drop<DataType>;

DataTypeCopy

Fully qualified path: pragma_lib::types::DataTypeCopy

impl DataTypeCopy of Copy<DataType>;

DataTypeSerde

Fully qualified path: pragma_lib::types::DataTypeSerde

impl DataTypeSerde of Serde<DataType>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::DataTypeSerde::serialize

fn serialize(self: @DataType, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::DataTypeSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<DataType>

PossibleEntryStorageDrop

Fully qualified path: pragma_lib::types::PossibleEntryStorageDrop

impl PossibleEntryStorageDrop of Drop<PossibleEntryStorage>;

PossibleEntryStorageCopy

Fully qualified path: pragma_lib::types::PossibleEntryStorageCopy

impl PossibleEntryStorageCopy of Copy<PossibleEntryStorage>;

SimpleDataTypeDrop

Fully qualified path: pragma_lib::types::SimpleDataTypeDrop

impl SimpleDataTypeDrop of Drop<SimpleDataType>;

SimpleDataTypeCopy

Fully qualified path: pragma_lib::types::SimpleDataTypeCopy

impl SimpleDataTypeCopy of Copy<SimpleDataType>;

SimpleDataTypeSerde

Fully qualified path: pragma_lib::types::SimpleDataTypeSerde

impl SimpleDataTypeSerde of Serde<SimpleDataType>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::SimpleDataTypeSerde::serialize

fn serialize(self: @SimpleDataType, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::SimpleDataTypeSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<SimpleDataType>

PossibleEntriesDrop

Fully qualified path: pragma_lib::types::PossibleEntriesDrop

impl PossibleEntriesDrop of Drop<PossibleEntries>;

PossibleEntriesCopy

Fully qualified path: pragma_lib::types::PossibleEntriesCopy

impl PossibleEntriesCopy of Copy<PossibleEntries>;

PossibleEntriesSerde

Fully qualified path: pragma_lib::types::PossibleEntriesSerde

impl PossibleEntriesSerde of Serde<PossibleEntries>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::PossibleEntriesSerde::serialize

fn serialize(self: @PossibleEntries, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::PossibleEntriesSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<PossibleEntries>

PairSerde

Fully qualified path: pragma_lib::types::PairSerde

impl PairSerde of Serde<Pair>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::PairSerde::serialize

fn serialize(self: @Pair, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::PairSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Pair>

PairDrop

Fully qualified path: pragma_lib::types::PairDrop

impl PairDrop of Drop<Pair>;

PairCopy

Fully qualified path: pragma_lib::types::PairCopy

impl PairCopy of Copy<Pair>;

PairStore

Fully qualified path: pragma_lib::types::PairStore

impl PairStore of Store<Pair>;

Impl functions

read

Fully qualified path: pragma_lib::types::PairStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Pair, Array<felt252>>

write

Fully qualified path: pragma_lib::types::PairStore::write

fn write(address_domain: u32, base: StorageBaseAddress, value: Pair) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::PairStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Pair, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::PairStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Pair,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::PairStore::size

fn size() -> u8

CurrencySerde

Fully qualified path: pragma_lib::types::CurrencySerde

impl CurrencySerde of Serde<Currency>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::CurrencySerde::serialize

fn serialize(self: @Currency, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::CurrencySerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Currency>

CurrencyDrop

Fully qualified path: pragma_lib::types::CurrencyDrop

impl CurrencyDrop of Drop<Currency>;

CurrencyCopy

Fully qualified path: pragma_lib::types::CurrencyCopy

impl CurrencyCopy of Copy<Currency>;

CurrencyStore

Fully qualified path: pragma_lib::types::CurrencyStore

impl CurrencyStore of Store<Currency>;

Impl functions

read

Fully qualified path: pragma_lib::types::CurrencyStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Currency, Array<felt252>>

write

Fully qualified path: pragma_lib::types::CurrencyStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: Currency,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::CurrencyStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Currency, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::CurrencyStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Currency,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::CurrencyStore::size

fn size() -> u8

CheckpointSerde

Fully qualified path: pragma_lib::types::CheckpointSerde

impl CheckpointSerde of Serde<Checkpoint>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::CheckpointSerde::serialize

fn serialize(self: @Checkpoint, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::CheckpointSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Checkpoint>

CheckpointDrop

Fully qualified path: pragma_lib::types::CheckpointDrop

impl CheckpointDrop of Drop<Checkpoint>;

FetchCheckpointSerde

Fully qualified path: pragma_lib::types::FetchCheckpointSerde

impl FetchCheckpointSerde of Serde<FetchCheckpoint>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::FetchCheckpointSerde::serialize

fn serialize(self: @FetchCheckpoint, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::FetchCheckpointSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<FetchCheckpoint>

FetchCheckpointDrop

Fully qualified path: pragma_lib::types::FetchCheckpointDrop

impl FetchCheckpointDrop of Drop<FetchCheckpoint>;

FetchCheckpointCopy

Fully qualified path: pragma_lib::types::FetchCheckpointCopy

impl FetchCheckpointCopy of Copy<FetchCheckpoint>;

FetchCheckpointStore

Fully qualified path: pragma_lib::types::FetchCheckpointStore

impl FetchCheckpointStore of Store<FetchCheckpoint>;

Impl functions

read

Fully qualified path: pragma_lib::types::FetchCheckpointStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<FetchCheckpoint, Array<felt252>>

write

Fully qualified path: pragma_lib::types::FetchCheckpointStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: FetchCheckpoint,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::FetchCheckpointStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<FetchCheckpoint, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::FetchCheckpointStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: FetchCheckpoint,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::FetchCheckpointStore::size

fn size() -> u8

PragmaPricesResponseSerde

Fully qualified path: pragma_lib::types::PragmaPricesResponseSerde

impl PragmaPricesResponseSerde of Serde<PragmaPricesResponse>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::PragmaPricesResponseSerde::serialize

fn serialize(self: @PragmaPricesResponse, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::PragmaPricesResponseSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<PragmaPricesResponse>

PragmaPricesResponseDrop

Fully qualified path: pragma_lib::types::PragmaPricesResponseDrop

impl PragmaPricesResponseDrop of Drop<PragmaPricesResponse>;

PragmaPricesResponseCopy

Fully qualified path: pragma_lib::types::PragmaPricesResponseCopy

impl PragmaPricesResponseCopy of Copy<PragmaPricesResponse>;

AggregationModeSerde

Fully qualified path: pragma_lib::types::AggregationModeSerde

impl AggregationModeSerde of Serde<AggregationMode>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::AggregationModeSerde::serialize

fn serialize(self: @AggregationMode, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::AggregationModeSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<AggregationMode>

AggregationModeDrop

Fully qualified path: pragma_lib::types::AggregationModeDrop

impl AggregationModeDrop of Drop<AggregationMode>;

AggregationModeCopy

Fully qualified path: pragma_lib::types::AggregationModeCopy

impl AggregationModeCopy of Copy<AggregationMode>;

EscalationManagerSettingsDrop

Fully qualified path: pragma_lib::types::EscalationManagerSettingsDrop

impl EscalationManagerSettingsDrop of Drop<EscalationManagerSettings>;

EscalationManagerSettingsSerde

Fully qualified path: pragma_lib::types::EscalationManagerSettingsSerde

impl EscalationManagerSettingsSerde of Serde<EscalationManagerSettings>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::EscalationManagerSettingsSerde::serialize

fn serialize(self: @EscalationManagerSettings, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::EscalationManagerSettingsSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<EscalationManagerSettings>

EscalationManagerSettingsCopy

Fully qualified path: pragma_lib::types::EscalationManagerSettingsCopy

impl EscalationManagerSettingsCopy of Copy<EscalationManagerSettings>;

EscalationManagerSettingsStore

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore

impl EscalationManagerSettingsStore of Store<EscalationManagerSettings>;

Impl functions

read

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore::read

fn read(
    address_domain: u32, base: StorageBaseAddress,
) -> Result<EscalationManagerSettings, Array<felt252>>

write

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: EscalationManagerSettings,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<EscalationManagerSettings, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: EscalationManagerSettings,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::EscalationManagerSettingsStore::size

fn size() -> u8

AssertionDrop

Fully qualified path: pragma_lib::types::AssertionDrop

impl AssertionDrop of Drop<Assertion>;

AssertionSerde

Fully qualified path: pragma_lib::types::AssertionSerde

impl AssertionSerde of Serde<Assertion>;

Impl functions

serialize

Fully qualified path: pragma_lib::types::AssertionSerde::serialize

fn serialize(self: @Assertion, ref output: Array<felt252>)

deserialize

Fully qualified path: pragma_lib::types::AssertionSerde::deserialize

fn deserialize(ref serialized: Span<felt252>) -> Option<Assertion>

AssertionCopy

Fully qualified path: pragma_lib::types::AssertionCopy

impl AssertionCopy of Copy<Assertion>;

AssertionStore

Fully qualified path: pragma_lib::types::AssertionStore

impl AssertionStore of Store<Assertion>;

Impl functions

read

Fully qualified path: pragma_lib::types::AssertionStore::read

fn read(address_domain: u32, base: StorageBaseAddress) -> Result<Assertion, Array<felt252>>

write

Fully qualified path: pragma_lib::types::AssertionStore::write

fn write(
    address_domain: u32, base: StorageBaseAddress, value: Assertion,
) -> Result<(), Array<felt252>>

read_at_offset

Fully qualified path: pragma_lib::types::AssertionStore::read_at_offset

fn read_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8,
) -> Result<Assertion, Array<felt252>>

write_at_offset

Fully qualified path: pragma_lib::types::AssertionStore::write_at_offset

fn write_at_offset(
    address_domain: u32, base: StorageBaseAddress, offset: u8, value: Assertion,
) -> Result<(), Array<felt252>>

size

Fully qualified path: pragma_lib::types::AssertionStore::size

fn size() -> u8

dispatchers

• Structs

• Traits

• Impls

Structs

Structs

IPragmaABIDispatcher

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IPragmaABIDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::IPragmaABIDispatcher::contract_address

pub contract_address: ContractAddress

IPragmaABILibraryDispatcher

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IPragmaABILibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IPragmaABILibraryDispatcher::class_hash

pub class_hash: ClassHash

IPragmaABISafeLibraryDispatcher

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IPragmaABISafeLibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IPragmaABISafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IPragmaABISafeDispatcher

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IPragmaABISafeDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::IPragmaABISafeDispatcher::contract_address

pub contract_address: ContractAddress

ISummaryStatsABIDispatcher

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct ISummaryStatsABIDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::ISummaryStatsABIDispatcher::contract_address

pub contract_address: ContractAddress

ISummaryStatsABILibraryDispatcher

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct ISummaryStatsABILibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::ISummaryStatsABILibraryDispatcher::class_hash

pub class_hash: ClassHash

ISummaryStatsABISafeLibraryDispatcher

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct ISummaryStatsABISafeLibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

ISummaryStatsABISafeDispatcher

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct ISummaryStatsABISafeDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::ISummaryStatsABISafeDispatcher::contract_address

pub contract_address: ContractAddress

IYieldCurveABIDispatcher

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IYieldCurveABIDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::IYieldCurveABIDispatcher::contract_address

pub contract_address: ContractAddress

IYieldCurveABILibraryDispatcher

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IYieldCurveABILibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IYieldCurveABILibraryDispatcher::class_hash

pub class_hash: ClassHash

IYieldCurveABISafeLibraryDispatcher

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IYieldCurveABISafeLibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IYieldCurveABISafeDispatcher

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IYieldCurveABISafeDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::IYieldCurveABISafeDispatcher::contract_address

pub contract_address: ContractAddress

IRandomnessDispatcher

Fully qualified path: pragma_lib::abi::IRandomnessDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IRandomnessDispatcher {
    pub contract_address: ContractAddress,
}

Members

contract_address

Fully qualified path: pragma_lib::abi::IRandomnessDispatcher::contract_address

pub contract_address: ContractAddress

IRandomnessLibraryDispatcher

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IRandomnessLibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IRandomnessLibraryDispatcher::class_hash

pub class_hash: ClassHash

IRandomnessSafeLibraryDispatcher

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IRandomnessSafeLibraryDispatcher {
    pub class_hash: ClassHash,
}

Members

class_hash

Fully qualified path: pragma_lib::abi::IRandomnessSafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IRandomnessSafeDispatcher

Fully qualified path: pragma_lib::abi::IRandomnessSafeDispatcher

Part of the group: dispatchers

[doc(group: "dispatchers")]
[derive(Copy, Drop, starknet::Store, Serde)]
struct IRandomnessSafeDispatcher {
    pub contract_address: ContractAddress,
}