integrity

Fully qualified path: integrity

Modules

Modules

Modules

settings

Fully qualified path: integrity::settings

Free functions

Structs

Enums

Type aliases

Impls

Free functions

Free functions

split_settings

Fully qualified path: integrity::settings::split_settings

fn split_settings(verifier_config: VerifierConfiguration) -> (VerifierSettings, VerifierPreset)

Structs

Structs

VerifierSettings

Fully qualified path: integrity::settings::VerifierSettings

#[derive(Drop, Copy, Serde, starknet::Store)]
struct VerifierSettings {
    memory_verification: felt252,
    hasher_bit_length: HasherBitLength,
    stone_version: StoneVersion,
}

Members

memory_verification

Fully qualified path: integrity::settings::VerifierSettings::memory_verification

memory_verification: felt252

hasher_bit_length

Fully qualified path: integrity::settings::VerifierSettings::hasher_bit_length

hasher_bit_length: HasherBitLength

stone_version

Fully qualified path: integrity::settings::VerifierSettings::stone_version

stone_version: StoneVersion

VerifierPreset

Fully qualified path: integrity::settings::VerifierPreset

[derive(Drop, Copy, Serde)]
struct VerifierPreset {
    layout: felt252,
    hasher: felt252,
}

Members

layout

Fully qualified path: integrity::settings::VerifierPreset::layout

layout: felt252

hasher

Fully qualified path: integrity::settings::VerifierPreset::hasher

hasher: felt252

VerifierConfiguration

Fully qualified path: integrity::settings::VerifierConfiguration

[derive(Drop, Copy, Serde, starknet::Store)]
struct VerifierConfiguration {
    layout: felt252,
    hasher: felt252,
    stone_version: felt252,
    memory_verification: felt252,
}

Members

layout

Fully qualified path: integrity::settings::VerifierConfiguration::layout

layout: felt252

hasher

Fully qualified path: integrity::settings::VerifierConfiguration::hasher

hasher: felt252

stone_version

Fully qualified path: integrity::settings::VerifierConfiguration::stone_version

stone_version: felt252

memory_verification

Fully qualified path: integrity::settings::VerifierConfiguration::memory_verification

memory_verification: felt252

Enums

Enums

MemoryVerification

Fully qualified path: integrity::settings::MemoryVerification

enum MemoryVerification {
    Strict,
    Relaxed,
    Cairo1,
}

Variants

Strict

Fully qualified path: integrity::settings::MemoryVerification::Strict

Strict

Relaxed

Fully qualified path: integrity::settings::MemoryVerification::Relaxed

Relaxed

Cairo1

Fully qualified path: integrity::settings::MemoryVerification::Cairo1

Cairo1

HasherBitLength

Fully qualified path: integrity::settings::HasherBitLength

enum HasherBitLength {
    Lsb160,
    Lsb248,
}

Variants

Lsb160

Fully qualified path: integrity::settings::HasherBitLength::Lsb160

Lsb160

Lsb248

Fully qualified path: integrity::settings::HasherBitLength::Lsb248

Lsb248

StoneVersion

Fully qualified path: integrity::settings::StoneVersion

enum StoneVersion {
    Stone5,
    Stone6,
}

Variants

Stone5

Fully qualified path: integrity::settings::StoneVersion::Stone5

Stone5

Stone6

Fully qualified path: integrity::settings::StoneVersion::Stone6

Stone6

Type aliases

Type aliases

FactHash

Fully qualified path: integrity::settings::FactHash

type FactHash = felt252;

VerificationHash

Fully qualified path: integrity::settings::VerificationHash

type VerificationHash = felt252;

PresetHash

Fully qualified path: integrity::settings::PresetHash

type PresetHash = felt252;

SecurityBits

Fully qualified path: integrity::settings::SecurityBits

type SecurityBits = u32;

JobId

Fully qualified path: integrity::settings::JobId

type JobId = felt252;

Impls

Impls

MemoryVerificationDrop

Fully qualified path: integrity::settings::MemoryVerificationDrop

impl MemoryVerificationDrop of Drop<MemoryVerification>;

MemoryVerificationCopy

Fully qualified path: integrity::settings::MemoryVerificationCopy

impl MemoryVerificationCopy of Copy<MemoryVerification>;

MemoryVerificationPartialEq

Fully qualified path: integrity::settings::MemoryVerificationPartialEq

impl MemoryVerificationPartialEq of PartialEq<MemoryVerification>;

Impl functions

eq

Fully qualified path: integrity::settings::MemoryVerificationPartialEq::eq

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

MemoryVerificationSerde

Fully qualified path: integrity::settings::MemoryVerificationSerde

impl MemoryVerificationSerde of Serde<MemoryVerification>;

Impl functions

serialize

Fully qualified path: integrity::settings::MemoryVerificationSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::MemoryVerificationSerde::deserialize

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

MemoryVerificationStore

Fully qualified path: integrity::settings::MemoryVerificationStore

impl MemoryVerificationStore of Store<MemoryVerification>;

Impl functions

read

Fully qualified path: integrity::settings::MemoryVerificationStore::read

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

write

Fully qualified path: integrity::settings::MemoryVerificationStore::write

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

read_at_offset

Fully qualified path: integrity::settings::MemoryVerificationStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::settings::MemoryVerificationStore::write_at_offset

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

size

Fully qualified path: integrity::settings::MemoryVerificationStore::size

fn size() -> u8

HasherBitLengthDrop

Fully qualified path: integrity::settings::HasherBitLengthDrop

impl HasherBitLengthDrop of Drop<HasherBitLength>;

HasherBitLengthCopy

Fully qualified path: integrity::settings::HasherBitLengthCopy

impl HasherBitLengthCopy of Copy<HasherBitLength>;

HasherBitLengthPartialEq

Fully qualified path: integrity::settings::HasherBitLengthPartialEq

impl HasherBitLengthPartialEq of PartialEq<HasherBitLength>;

Impl functions

eq

Fully qualified path: integrity::settings::HasherBitLengthPartialEq::eq

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

HasherBitLengthSerde

Fully qualified path: integrity::settings::HasherBitLengthSerde

impl HasherBitLengthSerde of Serde<HasherBitLength>;

Impl functions

serialize

Fully qualified path: integrity::settings::HasherBitLengthSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::HasherBitLengthSerde::deserialize

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

HasherBitLengthStore

Fully qualified path: integrity::settings::HasherBitLengthStore

impl HasherBitLengthStore of Store<HasherBitLength>;

Impl functions

read

Fully qualified path: integrity::settings::HasherBitLengthStore::read

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

write

Fully qualified path: integrity::settings::HasherBitLengthStore::write

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

read_at_offset

Fully qualified path: integrity::settings::HasherBitLengthStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::settings::HasherBitLengthStore::write_at_offset

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

size

Fully qualified path: integrity::settings::HasherBitLengthStore::size

fn size() -> u8

StoneVersionDrop

Fully qualified path: integrity::settings::StoneVersionDrop

impl StoneVersionDrop of Drop<StoneVersion>;

StoneVersionCopy

Fully qualified path: integrity::settings::StoneVersionCopy

impl StoneVersionCopy of Copy<StoneVersion>;

StoneVersionPartialEq

Fully qualified path: integrity::settings::StoneVersionPartialEq

impl StoneVersionPartialEq of PartialEq<StoneVersion>;

Impl functions

eq

Fully qualified path: integrity::settings::StoneVersionPartialEq::eq

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

StoneVersionSerde

Fully qualified path: integrity::settings::StoneVersionSerde

impl StoneVersionSerde of Serde<StoneVersion>;

Impl functions

serialize

Fully qualified path: integrity::settings::StoneVersionSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::StoneVersionSerde::deserialize

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

StoneVersionStore

Fully qualified path: integrity::settings::StoneVersionStore

impl StoneVersionStore of Store<StoneVersion>;

Impl functions

read

Fully qualified path: integrity::settings::StoneVersionStore::read

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

write

Fully qualified path: integrity::settings::StoneVersionStore::write

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

read_at_offset

Fully qualified path: integrity::settings::StoneVersionStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::settings::StoneVersionStore::write_at_offset

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

size

Fully qualified path: integrity::settings::StoneVersionStore::size

fn size() -> u8

VerifierSettingsDrop

Fully qualified path: integrity::settings::VerifierSettingsDrop

impl VerifierSettingsDrop of Drop<VerifierSettings>;

VerifierSettingsCopy

Fully qualified path: integrity::settings::VerifierSettingsCopy

impl VerifierSettingsCopy of Copy<VerifierSettings>;

VerifierSettingsSerde

Fully qualified path: integrity::settings::VerifierSettingsSerde

impl VerifierSettingsSerde of Serde<VerifierSettings>;

Impl functions

serialize

Fully qualified path: integrity::settings::VerifierSettingsSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::VerifierSettingsSerde::deserialize

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

VerifierSettingsStore

Fully qualified path: integrity::settings::VerifierSettingsStore

impl VerifierSettingsStore of Store<VerifierSettings>;

Impl functions

read

Fully qualified path: integrity::settings::VerifierSettingsStore::read

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

write

Fully qualified path: integrity::settings::VerifierSettingsStore::write

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

read_at_offset

Fully qualified path: integrity::settings::VerifierSettingsStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::settings::VerifierSettingsStore::write_at_offset

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

size

Fully qualified path: integrity::settings::VerifierSettingsStore::size

fn size() -> u8

VerifierPresetDrop

Fully qualified path: integrity::settings::VerifierPresetDrop

impl VerifierPresetDrop of Drop<VerifierPreset>;

VerifierPresetCopy

Fully qualified path: integrity::settings::VerifierPresetCopy

impl VerifierPresetCopy of Copy<VerifierPreset>;

VerifierPresetSerde

Fully qualified path: integrity::settings::VerifierPresetSerde

impl VerifierPresetSerde of Serde<VerifierPreset>;

Impl functions

serialize

Fully qualified path: integrity::settings::VerifierPresetSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::VerifierPresetSerde::deserialize

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

VerifierConfigurationDrop

Fully qualified path: integrity::settings::VerifierConfigurationDrop

impl VerifierConfigurationDrop of Drop<VerifierConfiguration>;

VerifierConfigurationCopy

Fully qualified path: integrity::settings::VerifierConfigurationCopy

impl VerifierConfigurationCopy of Copy<VerifierConfiguration>;

VerifierConfigurationSerde

Fully qualified path: integrity::settings::VerifierConfigurationSerde

impl VerifierConfigurationSerde of Serde<VerifierConfiguration>;

Impl functions

serialize

Fully qualified path: integrity::settings::VerifierConfigurationSerde::serialize

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

deserialize

Fully qualified path: integrity::settings::VerifierConfigurationSerde::deserialize

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

VerifierConfigurationStore

Fully qualified path: integrity::settings::VerifierConfigurationStore

impl VerifierConfigurationStore of Store<VerifierConfiguration>;

Impl functions

read

Fully qualified path: integrity::settings::VerifierConfigurationStore::read

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

write

Fully qualified path: integrity::settings::VerifierConfigurationStore::write

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

read_at_offset

Fully qualified path: integrity::settings::VerifierConfigurationStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::settings::VerifierConfigurationStore::write_at_offset

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

size

Fully qualified path: integrity::settings::VerifierConfigurationStore::size

fn size() -> u8

contracts

Fully qualified path: integrity::contracts

Modules

Modules

Modules

fact_registry_interface

Fully qualified path: integrity::contracts::fact_registry_interface

Modules

Structs

Traits

Impls

Groups:

dispatchers

• Structs

• Traits

• Impls

Modules

Modules

__external_IFactRegistryForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__external_IFactRegistryForwardImpl

__l1_handler_IFactRegistryForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__l1_handler_IFactRegistryForwardImpl

__constructor_IFactRegistryForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__constructor_IFactRegistryForwardImpl

__external_IFactRegistryWithMockingForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__external_IFactRegistryWithMockingForwardImpl

__l1_handler_IFactRegistryWithMockingForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__l1_handler_IFactRegistryWithMockingForwardImpl

__constructor_IFactRegistryWithMockingForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::__constructor_IFactRegistryWithMockingForwardImpl

Structs

Structs

VerificationListElement

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElement

#[derive(Drop, Copy, Serde)]
struct VerificationListElement {
    verification_hash: felt252,
    security_bits: u32,
    verifier_config: VerifierConfiguration,
}

Members

verification_hash

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElement::verification_hash

verification_hash: felt252

security_bits

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElement::security_bits

security_bits: u32

verifier_config

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElement::verifier_config

verifier_config: VerifierConfiguration

Verification

Fully qualified path: integrity::contracts::fact_registry_interface::Verification

#[derive(Drop, Copy, Serde, starknet::Store)]
struct Verification {
    fact_hash: felt252,
    security_bits: u32,
    verifier_config: VerifierConfiguration,
}

Members

fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::Verification::fact_hash

fact_hash: felt252

security_bits

Fully qualified path: integrity::contracts::fact_registry_interface::Verification::security_bits

security_bits: u32

verifier_config

Fully qualified path: integrity::contracts::fact_registry_interface::Verification::verifier_config

verifier_config: VerifierConfiguration

Traits

Traits

IFactRegistry

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistry

trait IFactRegistry<TContractState>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistry::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: @TContractState, fact_hash: felt252,
) -> Array<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistry::get_verification

fn get_verification(self: @TContractState, verification_hash: felt252) -> Option<Verification>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistry::get_verifier_address

fn get_verifier_address(self: @TContractState, preset: VerifierPreset) -> ContractAddress

IFactRegistryWithMocking

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMocking

pub trait IFactRegistryWithMocking<TContractState>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMocking::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: @TContractState, fact_hash: felt252, is_mocked: bool,
) -> Span<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMocking::get_verification

fn get_verification(
    self: @TContractState, verification_hash: felt252, is_mocked: bool,
) -> Option<Verification>

UnsafeNewContractStateTraitForIFactRegistryForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::UnsafeNewContractStateTraitForIFactRegistryForwardImpl

trait UnsafeNewContractStateTraitForIFactRegistryForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: integrity::contracts::fact_registry_interface::UnsafeNewContractStateTraitForIFactRegistryForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

UnsafeNewContractStateTraitForIFactRegistryWithMockingForwardImpl

Fully qualified path: integrity::contracts::fact_registry_interface::UnsafeNewContractStateTraitForIFactRegistryWithMockingForwardImpl

pub trait UnsafeNewContractStateTraitForIFactRegistryWithMockingForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: integrity::contracts::fact_registry_interface::UnsafeNewContractStateTraitForIFactRegistryWithMockingForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

Impls

Impls

VerificationListElementDrop

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElementDrop

impl VerificationListElementDrop of Drop<VerificationListElement>;

VerificationListElementCopy

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElementCopy

impl VerificationListElementCopy of Copy<VerificationListElement>;

VerificationListElementSerde

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElementSerde

impl VerificationListElementSerde of Serde<VerificationListElement>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElementSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationListElementSerde::deserialize

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

VerificationDrop

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationDrop

impl VerificationDrop of Drop<Verification>;

VerificationCopy

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationCopy

impl VerificationCopy of Copy<Verification>;

VerificationSerde

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationSerde

impl VerificationSerde of Serde<Verification>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationSerde::deserialize

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

VerificationStore

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore

impl VerificationStore of Store<Verification>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::VerificationStore::size

fn size() -> u8

IFactRegistryDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore

impl IFactRegistryDispatcherStore of Store<IFactRegistryDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherStore::size

fn size() -> u8

IFactRegistryLibraryDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore

impl IFactRegistryLibraryDispatcherStore of Store<IFactRegistryLibraryDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherStore::size

fn size() -> u8

IFactRegistrySafeLibraryDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore

impl IFactRegistrySafeLibraryDispatcherStore of Store<IFactRegistrySafeLibraryDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherStore::size

fn size() -> u8

IFactRegistrySafeDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore

impl IFactRegistrySafeDispatcherStore of Store<IFactRegistrySafeDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherStore::size

fn size() -> u8

IFactRegistryWithMockingDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore

impl IFactRegistryWithMockingDispatcherStore of Store<IFactRegistryWithMockingDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherStore::size

fn size() -> u8

IFactRegistryWithMockingLibraryDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore

impl IFactRegistryWithMockingLibraryDispatcherStore of Store<
    IFactRegistryWithMockingLibraryDispatcher,
>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherStore::size

fn size() -> u8

IFactRegistryWithMockingSafeLibraryDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore

impl IFactRegistryWithMockingSafeLibraryDispatcherStore of Store<
    IFactRegistryWithMockingSafeLibraryDispatcher,
>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherStore::size

fn size() -> u8

IFactRegistryWithMockingSafeDispatcherStore

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore

impl IFactRegistryWithMockingSafeDispatcherStore of Store<IFactRegistryWithMockingSafeDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherStore::size

fn size() -> u8

mocked_fact_registry

Fully qualified path: integrity::contracts::mocked_fact_registry

Modules

Structs

Traits

Impls

Groups:

dispatchers

• Structs

• Traits

• Impls

Modules

Modules

MockedFactRegistry

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry

Free functions

Structs

Enums

Traits

Impls

Free functions

Free functions

unsafe_new_contract_state

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::unsafe_new_contract_state

pub fn unsafe_new_contract_state() -> ContractState

Structs

Structs

Storage

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::Storage

[phantom]
pub struct Storage {
    pub fact_verifications: Map<felt252, Vec<felt252>>,
    pub verification_hashes: Map<felt252, Option<Verification>>,
}

Members

fact_verifications

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::Storage::fact_verifications

pub fact_verifications: Map<felt252, Vec<felt252>>

verification_hashes

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::Storage::verification_hashes

pub verification_hashes: Map<felt252, Option<Verification>>

ContractState

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractState

pub struct ContractState {}

Enums

Enums

Event

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::Event

enum Event {
    FactRegistered: FactRegistered,
}

Variants

FactRegistered

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::Event::FactRegistered

FactRegistered: FactRegistered

Traits

Traits

InternalFactRegistryTrait

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistryTrait

trait InternalFactRegistryTrait

Trait functions

_hash_preset

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistryTrait::_hash_preset

fn _hash_preset(self: @ContractState, preset: VerifierPreset) -> felt252

_register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistryTrait::_register_fact

fn _register_fact(
    ref self: ContractState,
    fact_hash: felt252,
    verifier_address: ContractAddress,
    security_bits: u32,
    verifier_config: VerifierConfiguration,
) -> FactRegistered

Impls

Impls

FactRegistryExternalImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryExternalImpl

impl FactRegistryExternalImpl of IFactRegistryExternal<ContractState>;

Impl functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryExternalImpl::register_fact

fn register_fact(
    ref self: ContractState,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> FactRegistered

FactRegistryImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryImpl

impl FactRegistryImpl of IFactRegistry<ContractState>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: @ContractState, fact_hash: felt252,
) -> Array<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryImpl::get_verification

fn get_verification(self: @ContractState, verification_hash: felt252) -> Option<Verification>

get_verifier_address

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::FactRegistryImpl::get_verifier_address

fn get_verifier_address(self: @ContractState, preset: VerifierPreset) -> ContractAddress

InternalFactRegistry

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistry

impl InternalFactRegistry of InternalFactRegistryTrait;

Impl functions

_hash_preset

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistry::_hash_preset

fn _hash_preset(self: @ContractState, preset: VerifierPreset) -> felt252

_register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::InternalFactRegistry::_register_fact

fn _register_fact(
    ref self: ContractState,
    fact_hash: felt252,
    verifier_address: ContractAddress,
    security_bits: u32,
    verifier_config: VerifierConfiguration,
) -> FactRegistered

ContractStateDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateDrop

impl ContractStateDrop of Drop<ContractState>;

ContractStateDerefMut

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateDerefMut

impl ContractStateDerefMut of DerefMut<ContractState>;

Impl functions

deref_mut

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateDerefMut::deref_mut

fn deref_mut(ref self: ContractState) -> FlattenedStorage<Mutable<Storage>>

Impl types

Target

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateDerefMut::Target

type Target = FlattenedStorage<Mutable<Storage>>;

ContractStateEventEmitter

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateEventEmitter

impl ContractStateEventEmitter of EventEmitter<ContractState, Event>;

Impl functions

emit

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::ContractStateEventEmitter::emit

fn emit(ref self: ContractState, event: S)

EventDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventDrop

impl EventDrop of Drop<Event>;

EventIsEvent

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventIsEvent

impl EventIsEvent of Event<Event>;

Impl functions

append_keys_and_data

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventIsEvent::append_keys_and_data

fn append_keys_and_data(self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>)

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventIsEvent::deserialize

fn deserialize(ref keys: Span<felt252>, ref data: Span<felt252>) -> Option<Event>

EventFactRegisteredIntoEvent

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventFactRegisteredIntoEvent

impl EventFactRegisteredIntoEvent of Into<FactRegistered, Event>;

Impl functions

into

Fully qualified path: integrity::contracts::mocked_fact_registry::MockedFactRegistry::EventFactRegisteredIntoEvent::into

fn into(self: FactRegistered) -> Event

__external_IFactRegistryExternalForwardImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::__external_IFactRegistryExternalForwardImpl

__l1_handler_IFactRegistryExternalForwardImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::__l1_handler_IFactRegistryExternalForwardImpl

__constructor_IFactRegistryExternalForwardImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::__constructor_IFactRegistryExternalForwardImpl

Structs

Structs

FactRegistered

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered

#[derive(Drop, Copy, Serde, starknet::Event)]
struct FactRegistered {
    fact_hash: felt252,
    verifier_address: ContractAddress,
    security_bits: u32,
    verifier_config: VerifierConfiguration,
    verification_hash: felt252,
}

Members

fact_hash

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered::fact_hash

fact_hash: felt252

verifier_address

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered::verifier_address

verifier_address: ContractAddress

security_bits

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered::security_bits

security_bits: u32

verifier_config

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered::verifier_config

verifier_config: VerifierConfiguration

verification_hash

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegistered::verification_hash

verification_hash: felt252

Traits

Traits

IFactRegistryExternal

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternal

trait IFactRegistryExternal<TContractState>

Trait functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternal::register_fact

fn register_fact(
    ref self: TContractState,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> FactRegistered

UnsafeNewContractStateTraitForIFactRegistryExternalForwardImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::UnsafeNewContractStateTraitForIFactRegistryExternalForwardImpl

trait UnsafeNewContractStateTraitForIFactRegistryExternalForwardImpl<TContractState>

Trait functions

unsafe_new_contract_state

Fully qualified path: integrity::contracts::mocked_fact_registry::UnsafeNewContractStateTraitForIFactRegistryExternalForwardImpl::unsafe_new_contract_state

fn unsafe_new_contract_state() -> TContractState

Impls

Impls

FactRegisteredDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredDrop

impl FactRegisteredDrop of Drop<FactRegistered>;

FactRegisteredCopy

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredCopy

impl FactRegisteredCopy of Copy<FactRegistered>;

FactRegisteredSerde

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredSerde

impl FactRegisteredSerde of Serde<FactRegistered>;

Impl functions

serialize

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredSerde::deserialize

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

FactRegisteredIsEvent

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredIsEvent

impl FactRegisteredIsEvent of Event<FactRegistered>;

Impl functions

append_keys_and_data

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredIsEvent::append_keys_and_data

fn append_keys_and_data(self: @FactRegistered, ref keys: Array<felt252>, ref data: Array<felt252>)

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::FactRegisteredIsEvent::deserialize

fn deserialize(ref keys: Span<felt252>, ref data: Span<felt252>) -> Option<FactRegistered>

IFactRegistryExternalDispatcherStore

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore

impl IFactRegistryExternalDispatcherStore of Store<IFactRegistryExternalDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherStore::size

fn size() -> u8

IFactRegistryExternalLibraryDispatcherStore

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore

impl IFactRegistryExternalLibraryDispatcherStore of Store<IFactRegistryExternalLibraryDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherStore::size

fn size() -> u8

IFactRegistryExternalSafeLibraryDispatcherStore

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore

impl IFactRegistryExternalSafeLibraryDispatcherStore of Store<
    IFactRegistryExternalSafeLibraryDispatcher,
>;

Impl functions

read

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherStore::size

fn size() -> u8

IFactRegistryExternalSafeDispatcherStore

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore

impl IFactRegistryExternalSafeDispatcherStore of Store<IFactRegistryExternalSafeDispatcher>;

Impl functions

read

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore::read

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

write

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore::write

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

read_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore::read_at_offset

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

write_at_offset

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore::write_at_offset

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

size

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherStore::size

fn size() -> u8

lib_utils

Fully qualified path: integrity::lib_utils

Constants

Free functions

Structs

Traits

Impls

Constants

Constants

CHAIN_ID_SEPOLIA

Fully qualified path: integrity::lib_utils::CHAIN_ID_SEPOLIA

const CHAIN_ID_SEPOLIA: felt252 = 393402133025997798000961;

INTEGRITY_ADDRESS_SEPOLIA

Fully qualified path: integrity::lib_utils::INTEGRITY_ADDRESS_SEPOLIA

const INTEGRITY_ADDRESS_SEPOLIA: felt252 =
    2174052308274356636763119029510770605148982738072392389606633881451432975244;

PROXY_ADDRESS_SEPOLIA

Fully qualified path: integrity::lib_utils::PROXY_ADDRESS_SEPOLIA

const PROXY_ADDRESS_SEPOLIA: felt252 =
    629065276720760987812742147242595193815756910152585667959252983277443673882;

SATELLITE_ADDRESS_SEPOLIA

Fully qualified path: integrity::lib_utils::SATELLITE_ADDRESS_SEPOLIA

const SATELLITE_ADDRESS_SEPOLIA: felt252 =
    116811015551115539595067500555427173277664473764061460140451192447694169966;

CHAIN_ID_MAINNET

Fully qualified path: integrity::lib_utils::CHAIN_ID_MAINNET

const CHAIN_ID_MAINNET: felt252 = 23448594291968334;

INTEGRITY_ADDRESS_MAINNET

Fully qualified path: integrity::lib_utils::INTEGRITY_ADDRESS_MAINNET

const INTEGRITY_ADDRESS_MAINNET: felt252 =
    361124439182224978572396503539947998388148542921218839478772054697837916171;

PROXY_ADDRESS_MAINNET

Fully qualified path: integrity::lib_utils::PROXY_ADDRESS_MAINNET

const PROXY_ADDRESS_MAINNET: felt252 =
    3012233734109596859803348298064544601708106612833123105772080083306783227568;

SATELLITE_ADDRESS_MAINNET

Fully qualified path: integrity::lib_utils::SATELLITE_ADDRESS_MAINNET

const SATELLITE_ADDRESS_MAINNET: felt252 =
    781811152086843110066869849768791115389451128574153231834503188231392706350;

SHARP_BOOTLOADER_PROGRAM_HASH

Fully qualified path: integrity::lib_utils::SHARP_BOOTLOADER_PROGRAM_HASH

const SHARP_BOOTLOADER_PROGRAM_HASH: felt252 =
    160268921359133235574810995023520895391777547407923205700393332203861498631;

STONE_BOOTLOADER_PROGRAM_HASH

Fully qualified path: integrity::lib_utils::STONE_BOOTLOADER_PROGRAM_HASH

const STONE_BOOTLOADER_PROGRAM_HASH: felt252 =
    1818260477999723824094094150114366796808025874741865313756902956116229622979;

CAIRO_VERIFIER_PROGRAM_HASH

Fully qualified path: integrity::lib_utils::CAIRO_VERIFIER_PROGRAM_HASH

const CAIRO_VERIFIER_PROGRAM_HASH: felt252 =
    712730369212649401599582154587278289724262079847619466250461974481240603296;

Free functions

Free functions

get_verifier_config_hash

Fully qualified path: integrity::lib_utils::get_verifier_config_hash

fn get_verifier_config_hash(verifier_config: VerifierConfiguration) -> felt252

get_verification_hash

Fully qualified path: integrity::lib_utils::get_verification_hash

fn get_verification_hash(
    fact_hash: felt252, verifier_config_hash: felt252, security_bits: u32,
) -> felt252

calculate_fact_hash

Fully qualified path: integrity::lib_utils::calculate_fact_hash

fn calculate_fact_hash(program_hash: felt252, output: Span<felt252>) -> felt252

calculate_bootloaded_fact_hash

Fully qualified path: integrity::lib_utils::calculate_bootloaded_fact_hash

fn calculate_bootloaded_fact_hash(
    bootloader_program_hash: felt252, child_program_hash: felt252, child_output: Span<felt252>,
) -> felt252

calculate_wrapped_bootloaded_fact_hash

Fully qualified path: integrity::lib_utils::calculate_wrapped_bootloaded_fact_hash

fn calculate_wrapped_bootloaded_fact_hash(
    wrapper_program_hash: felt252,
    bootloader_program_hash: felt252,
    child_program_hash: felt252,
    child_output: Span<felt252>,
) -> felt252

Structs

Structs

IntegrityT

Fully qualified path: integrity::lib_utils::IntegrityT

#[derive(Drop, Copy, Serde)]
struct IntegrityT {
    dispatcher: IFactRegistryDispatcher,
}

Members

dispatcher

Fully qualified path: integrity::lib_utils::IntegrityT::dispatcher

dispatcher: IFactRegistryDispatcher

SatelliteT

Fully qualified path: integrity::lib_utils::SatelliteT

#[derive(Drop, Copy, Serde)]
struct SatelliteT {
    dispatcher: IFactRegistryWithMockingDispatcher,
    is_mocked: bool,
}

Members

dispatcher

Fully qualified path: integrity::lib_utils::SatelliteT::dispatcher

dispatcher: IFactRegistryWithMockingDispatcher

is_mocked

Fully qualified path: integrity::lib_utils::SatelliteT::is_mocked

is_mocked: bool

IntegrityWithConfigT

Fully qualified path: integrity::lib_utils::IntegrityWithConfigT

[derive(Drop, Copy, Serde)]
struct IntegrityWithConfigT<Base> {
    base: Base,
    verifier_config_hash: felt252,
    security_bits: u32,
}

Members

base

Fully qualified path: integrity::lib_utils::IntegrityWithConfigT::base

base: Base

verifier_config_hash

Fully qualified path: integrity::lib_utils::IntegrityWithConfigT::verifier_config_hash

verifier_config_hash: felt252

security_bits

Fully qualified path: integrity::lib_utils::IntegrityWithConfigT::security_bits

security_bits: u32

Traits

Traits

CallFactRegistryTrait

Fully qualified path: integrity::lib_utils::CallFactRegistryTrait

trait CallFactRegistryTrait<T>

Trait functions

_get_all_verifications_for_fact_hash

Fully qualified path: integrity::lib_utils::CallFactRegistryTrait::_get_all_verifications_for_fact_hash

fn _get_all_verifications_for_fact_hash(
    self: T, fact_hash: felt252,
) -> Span<VerificationListElement>

_get_verification

Fully qualified path: integrity::lib_utils::CallFactRegistryTrait::_get_verification

fn _get_verification(self: T, verification_hash: felt252) -> Option<Verification>

IntegrityTrait

Fully qualified path: integrity::lib_utils::IntegrityTrait

trait IntegrityTrait

Trait functions

new

Fully qualified path: integrity::lib_utils::IntegrityTrait::new

fn new() -> IntegrityT

new_proxy

Fully qualified path: integrity::lib_utils::IntegrityTrait::new_proxy

fn new_proxy() -> IntegrityT

new_satellite

Fully qualified path: integrity::lib_utils::IntegrityTrait::new_satellite

fn new_satellite(is_mocked: bool) -> SatelliteT

from_address

Fully qualified path: integrity::lib_utils::IntegrityTrait::from_address

fn from_address(contract_address: ContractAddress) -> IntegrityT

is_fact_hash_valid_with_security

Fully qualified path: integrity::lib_utils::IntegrityTrait::is_fact_hash_valid_with_security

fn is_fact_hash_valid_with_security<T, +CallFactRegistryTrait<T>>(
    self: T, fact_hash: felt252, security_bits: u32,
) -> bool

is_verification_hash_valid

Fully qualified path: integrity::lib_utils::IntegrityTrait::is_verification_hash_valid

fn is_verification_hash_valid<T, +CallFactRegistryTrait<T>>(
    self: T, verification_hash: felt252,
) -> bool

with_config

Fully qualified path: integrity::lib_utils::IntegrityTrait::with_config

fn with_config<Base, +Drop<Base>>(
    self: Base, verifier_config: VerifierConfiguration, security_bits: u32,
) -> IntegrityWithConfigT<Base>

with_hashed_config

Fully qualified path: integrity::lib_utils::IntegrityTrait::with_hashed_config

fn with_hashed_config<Base, +Drop<Base>>(
    self: Base, verifier_config_hash: felt252, security_bits: u32,
) -> IntegrityWithConfigT<Base>

IntegrityWithConfigTrait

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTrait

trait IntegrityWithConfigTrait<Base, +Drop<Base>, +CallFactRegistryTrait<Base>>

Trait functions

is_fact_hash_valid

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTrait::is_fact_hash_valid

fn is_fact_hash_valid(self: IntegrityWithConfigT<Base>, fact_hash: felt252) -> bool

Impls

Impls

Integrity

Fully qualified path: integrity::lib_utils::Integrity

impl Integrity of IntegrityTrait;

Impl functions

new

Fully qualified path: integrity::lib_utils::Integrity::new

fn new() -> IntegrityT

new_proxy

Fully qualified path: integrity::lib_utils::Integrity::new_proxy

fn new_proxy() -> IntegrityT

new_satellite

Fully qualified path: integrity::lib_utils::Integrity::new_satellite

fn new_satellite(is_mocked: bool) -> SatelliteT

from_address

Fully qualified path: integrity::lib_utils::Integrity::from_address

fn from_address(contract_address: ContractAddress) -> IntegrityT

is_fact_hash_valid_with_security

Fully qualified path: integrity::lib_utils::Integrity::is_fact_hash_valid_with_security

fn is_fact_hash_valid_with_security(self: T, fact_hash: felt252, security_bits: u32) -> bool

is_verification_hash_valid

Fully qualified path: integrity::lib_utils::Integrity::is_verification_hash_valid

fn is_verification_hash_valid(self: T, verification_hash: felt252) -> bool

with_config

Fully qualified path: integrity::lib_utils::Integrity::with_config

fn with_config(
    self: Base, verifier_config: VerifierConfiguration, security_bits: u32,
) -> IntegrityWithConfigT<Base>

with_hashed_config

Fully qualified path: integrity::lib_utils::Integrity::with_hashed_config

fn with_hashed_config(
    self: Base, verifier_config_hash: felt252, security_bits: u32,
) -> IntegrityWithConfigT<Base>

IntegrityCallImpl

Fully qualified path: integrity::lib_utils::IntegrityCallImpl

impl IntegrityCallImpl of CallFactRegistryTrait<IntegrityT>;

Impl functions

_get_all_verifications_for_fact_hash

Fully qualified path: integrity::lib_utils::IntegrityCallImpl::_get_all_verifications_for_fact_hash

fn _get_all_verifications_for_fact_hash(
    self: IntegrityT, fact_hash: felt252,
) -> Span<VerificationListElement>

_get_verification

Fully qualified path: integrity::lib_utils::IntegrityCallImpl::_get_verification

fn _get_verification(self: IntegrityT, verification_hash: felt252) -> Option<Verification>

SatelliteCallImpl

Fully qualified path: integrity::lib_utils::SatelliteCallImpl

impl SatelliteCallImpl of CallFactRegistryTrait<SatelliteT>;

Impl functions

_get_all_verifications_for_fact_hash

Fully qualified path: integrity::lib_utils::SatelliteCallImpl::_get_all_verifications_for_fact_hash

fn _get_all_verifications_for_fact_hash(
    self: SatelliteT, fact_hash: felt252,
) -> Span<VerificationListElement>

_get_verification

Fully qualified path: integrity::lib_utils::SatelliteCallImpl::_get_verification

fn _get_verification(self: SatelliteT, verification_hash: felt252) -> Option<Verification>

IntegrityTDrop

Fully qualified path: integrity::lib_utils::IntegrityTDrop

impl IntegrityTDrop of Drop<IntegrityT>;

IntegrityTCopy

Fully qualified path: integrity::lib_utils::IntegrityTCopy

impl IntegrityTCopy of Copy<IntegrityT>;

IntegrityTSerde

Fully qualified path: integrity::lib_utils::IntegrityTSerde

impl IntegrityTSerde of Serde<IntegrityT>;

Impl functions

serialize

Fully qualified path: integrity::lib_utils::IntegrityTSerde::serialize

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

deserialize

Fully qualified path: integrity::lib_utils::IntegrityTSerde::deserialize

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

SatelliteTDrop

Fully qualified path: integrity::lib_utils::SatelliteTDrop

impl SatelliteTDrop of Drop<SatelliteT>;

SatelliteTCopy

Fully qualified path: integrity::lib_utils::SatelliteTCopy

impl SatelliteTCopy of Copy<SatelliteT>;

SatelliteTSerde

Fully qualified path: integrity::lib_utils::SatelliteTSerde

impl SatelliteTSerde of Serde<SatelliteT>;

Impl functions

serialize

Fully qualified path: integrity::lib_utils::SatelliteTSerde::serialize

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

deserialize

Fully qualified path: integrity::lib_utils::SatelliteTSerde::deserialize

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

IntegrityWithConfigTDrop

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTDrop

impl IntegrityWithConfigTDrop<
    Base, impl __MEMBER_IMPL_base_Drop: Drop<Base>,
> of Drop<IntegrityWithConfigT<Base>>;

IntegrityWithConfigTCopy

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTCopy

impl IntegrityWithConfigTCopy<
    Base, impl __MEMBER_IMPL_base_Copy: Copy<Base>,
> of Copy<IntegrityWithConfigT<Base>>;

IntegrityWithConfigTSerde

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTSerde

impl IntegrityWithConfigTSerde<
    Base,
    impl __MEMBER_IMPL_base_Serde: Serde<Base>,
    impl __MEMBER_IMPL_base_Destruct: Destruct<Base>,
> of Serde<IntegrityWithConfigT<Base>>;

Impl functions

serialize

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTSerde::serialize

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

deserialize

Fully qualified path: integrity::lib_utils::IntegrityWithConfigTSerde::deserialize

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

dispatchers

• Structs

• Traits

• Impls

Structs

Structs

IFactRegistryDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcher::contract_address

pub contract_address: ContractAddress

IFactRegistryLibraryDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistrySafeLibraryDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistrySafeDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcher::contract_address

pub contract_address: ContractAddress

IFactRegistryWithMockingDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcher::contract_address

pub contract_address: ContractAddress

IFactRegistryWithMockingLibraryDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistryWithMockingSafeLibraryDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistryWithMockingSafeDispatcher

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcher::contract_address

pub contract_address: ContractAddress

IFactRegistryExternalDispatcher

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcher::contract_address

pub contract_address: ContractAddress

IFactRegistryExternalLibraryDispatcher

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistryExternalSafeLibraryDispatcher

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcher

Part of the group: dispatchers

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

Members

class_hash

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcher::class_hash

pub class_hash: ClassHash

IFactRegistryExternalSafeDispatcher

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcher

Part of the group: dispatchers

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

Members

contract_address

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcher::contract_address

pub contract_address: ContractAddress

Traits

Traits

IFactRegistryDispatcherTrait

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherTrait

Part of the group: dispatchers

trait IFactRegistryDispatcherTrait<T>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherTrait::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: T, fact_hash: felt252,
) -> Array<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherTrait::get_verification

fn get_verification(self: T, verification_hash: felt252) -> Option<Verification>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherTrait::get_verifier_address

fn get_verifier_address(self: T, preset: VerifierPreset) -> ContractAddress

IFactRegistrySafeDispatcherTrait

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherTrait

Part of the group: dispatchers

trait IFactRegistrySafeDispatcherTrait<T>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherTrait::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: T, fact_hash: felt252,
) -> Result<Array<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherTrait::get_verification

fn get_verification(
    self: T, verification_hash: felt252,
) -> Result<Option<Verification>, Array<felt252>>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherTrait::get_verifier_address

fn get_verifier_address(self: T, preset: VerifierPreset) -> Result<ContractAddress, Array<felt252>>

IFactRegistryWithMockingDispatcherTrait

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherTrait

Part of the group: dispatchers

pub trait IFactRegistryWithMockingDispatcherTrait<T>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherTrait::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: T, fact_hash: felt252, is_mocked: bool,
) -> Span<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherTrait::get_verification

fn get_verification(self: T, verification_hash: felt252, is_mocked: bool) -> Option<Verification>

IFactRegistryWithMockingSafeDispatcherTrait

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherTrait

Part of the group: dispatchers

pub trait IFactRegistryWithMockingSafeDispatcherTrait<T>

Trait functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherTrait::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: T, fact_hash: felt252, is_mocked: bool,
) -> Result<Span<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherTrait::get_verification

fn get_verification(
    self: T, verification_hash: felt252, is_mocked: bool,
) -> Result<Option<Verification>, Array<felt252>>

IFactRegistryExternalDispatcherTrait

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherTrait

Part of the group: dispatchers

trait IFactRegistryExternalDispatcherTrait<T>

Trait functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherTrait::register_fact

fn register_fact(
    self: T, verifier_config: VerifierConfiguration, fact_hash: felt252, security_bits: u32,
) -> FactRegistered

IFactRegistryExternalSafeDispatcherTrait

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherTrait

Part of the group: dispatchers

trait IFactRegistryExternalSafeDispatcherTrait<T>

Trait functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherTrait::register_fact

fn register_fact(
    self: T, verifier_config: VerifierConfiguration, fact_hash: felt252, security_bits: u32,
) -> Result<FactRegistered, Array<felt252>>

Impls

Impls

IFactRegistryDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryDispatcherImpl of IFactRegistryDispatcherTrait<IFactRegistryDispatcher>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryDispatcher, fact_hash: felt252,
) -> Array<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryDispatcher, verification_hash: felt252,
) -> Option<Verification>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherImpl::get_verifier_address

fn get_verifier_address(self: IFactRegistryDispatcher, preset: VerifierPreset) -> ContractAddress

IFactRegistryLibraryDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryLibraryDispatcherImpl of IFactRegistryDispatcherTrait<
    IFactRegistryLibraryDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryLibraryDispatcher, fact_hash: felt252,
) -> Array<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryLibraryDispatcher, verification_hash: felt252,
) -> Option<Verification>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherImpl::get_verifier_address

fn get_verifier_address(
    self: IFactRegistryLibraryDispatcher, preset: VerifierPreset,
) -> ContractAddress

IFactRegistrySafeLibraryDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistrySafeLibraryDispatcherImpl of IFactRegistrySafeDispatcherTrait<
    IFactRegistrySafeLibraryDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistrySafeLibraryDispatcher, fact_hash: felt252,
) -> Result<Array<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistrySafeLibraryDispatcher, verification_hash: felt252,
) -> Result<Option<Verification>, Array<felt252>>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherImpl::get_verifier_address

fn get_verifier_address(
    self: IFactRegistrySafeLibraryDispatcher, preset: VerifierPreset,
) -> Result<ContractAddress, Array<felt252>>

IFactRegistrySafeDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherImpl

Part of the group: dispatchers

impl IFactRegistrySafeDispatcherImpl of IFactRegistrySafeDispatcherTrait<
    IFactRegistrySafeDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistrySafeDispatcher, fact_hash: felt252,
) -> Result<Array<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistrySafeDispatcher, verification_hash: felt252,
) -> Result<Option<Verification>, Array<felt252>>

get_verifier_address

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherImpl::get_verifier_address

fn get_verifier_address(
    self: IFactRegistrySafeDispatcher, preset: VerifierPreset,
) -> Result<ContractAddress, Array<felt252>>

IFactRegistryWithMockingDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryWithMockingDispatcherImpl of IFactRegistryWithMockingDispatcherTrait<
    IFactRegistryWithMockingDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryWithMockingDispatcher, fact_hash: felt252, is_mocked: bool,
) -> Span<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryWithMockingDispatcher, verification_hash: felt252, is_mocked: bool,
) -> Option<Verification>

IFactRegistryWithMockingLibraryDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryWithMockingLibraryDispatcherImpl of IFactRegistryWithMockingDispatcherTrait<
    IFactRegistryWithMockingLibraryDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryWithMockingLibraryDispatcher, fact_hash: felt252, is_mocked: bool,
) -> Span<VerificationListElement>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryWithMockingLibraryDispatcher, verification_hash: felt252, is_mocked: bool,
) -> Option<Verification>

IFactRegistryWithMockingSafeLibraryDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeLibraryDispatcherImpl of IFactRegistryWithMockingSafeDispatcherTrait<
    IFactRegistryWithMockingSafeLibraryDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryWithMockingSafeLibraryDispatcher, fact_hash: felt252, is_mocked: bool,
) -> Result<Span<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryWithMockingSafeLibraryDispatcher,
    verification_hash: felt252,
    is_mocked: bool,
) -> Result<Option<Verification>, Array<felt252>>

IFactRegistryWithMockingSafeDispatcherImpl

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeDispatcherImpl of IFactRegistryWithMockingSafeDispatcherTrait<
    IFactRegistryWithMockingSafeDispatcher,
>;

Impl functions

get_all_verifications_for_fact_hash

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherImpl::get_all_verifications_for_fact_hash

fn get_all_verifications_for_fact_hash(
    self: IFactRegistryWithMockingSafeDispatcher, fact_hash: felt252, is_mocked: bool,
) -> Result<Span<VerificationListElement>, Array<felt252>>

get_verification

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherImpl::get_verification

fn get_verification(
    self: IFactRegistryWithMockingSafeDispatcher, verification_hash: felt252, is_mocked: bool,
) -> Result<Option<Verification>, Array<felt252>>

IFactRegistryDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryDispatcherCopy of Copy<IFactRegistryDispatcher>;

IFactRegistryDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryDispatcherDrop of Drop<IFactRegistryDispatcher>;

IFactRegistryDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryDispatcherSerde of Serde<IFactRegistryDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryDispatcherSerde::deserialize

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

IFactRegistryLibraryDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryLibraryDispatcherCopy of Copy<IFactRegistryLibraryDispatcher>;

IFactRegistryLibraryDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryLibraryDispatcherDrop of Drop<IFactRegistryLibraryDispatcher>;

IFactRegistryLibraryDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryLibraryDispatcherSerde of Serde<IFactRegistryLibraryDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryLibraryDispatcherSerde::deserialize

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

IFactRegistrySafeLibraryDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistrySafeLibraryDispatcherCopy of Copy<IFactRegistrySafeLibraryDispatcher>;

IFactRegistrySafeLibraryDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistrySafeLibraryDispatcherDrop of Drop<IFactRegistrySafeLibraryDispatcher>;

IFactRegistrySafeLibraryDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistrySafeLibraryDispatcherSerde of Serde<IFactRegistrySafeLibraryDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeLibraryDispatcherSerde::deserialize

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

IFactRegistrySafeDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherCopy

Part of the group: dispatchers

impl IFactRegistrySafeDispatcherCopy of Copy<IFactRegistrySafeDispatcher>;

IFactRegistrySafeDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherDrop

Part of the group: dispatchers

impl IFactRegistrySafeDispatcherDrop of Drop<IFactRegistrySafeDispatcher>;

IFactRegistrySafeDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherSerde

Part of the group: dispatchers

impl IFactRegistrySafeDispatcherSerde of Serde<IFactRegistrySafeDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistrySafeDispatcherSerde::deserialize

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

IFactRegistryWithMockingDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryWithMockingDispatcherCopy of Copy<IFactRegistryWithMockingDispatcher>;

IFactRegistryWithMockingDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryWithMockingDispatcherDrop of Drop<IFactRegistryWithMockingDispatcher>;

IFactRegistryWithMockingDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryWithMockingDispatcherSerde of Serde<IFactRegistryWithMockingDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingDispatcherSerde::deserialize

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

IFactRegistryWithMockingLibraryDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryWithMockingLibraryDispatcherCopy of Copy<
    IFactRegistryWithMockingLibraryDispatcher,
>;

IFactRegistryWithMockingLibraryDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryWithMockingLibraryDispatcherDrop of Drop<
    IFactRegistryWithMockingLibraryDispatcher,
>;

IFactRegistryWithMockingLibraryDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryWithMockingLibraryDispatcherSerde of Serde<
    IFactRegistryWithMockingLibraryDispatcher,
>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingLibraryDispatcherSerde::deserialize

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

IFactRegistryWithMockingSafeLibraryDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeLibraryDispatcherCopy of Copy<
    IFactRegistryWithMockingSafeLibraryDispatcher,
>;

IFactRegistryWithMockingSafeLibraryDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeLibraryDispatcherDrop of Drop<
    IFactRegistryWithMockingSafeLibraryDispatcher,
>;

IFactRegistryWithMockingSafeLibraryDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeLibraryDispatcherSerde of Serde<
    IFactRegistryWithMockingSafeLibraryDispatcher,
>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeLibraryDispatcherSerde::deserialize

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

IFactRegistryWithMockingSafeDispatcherCopy

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeDispatcherCopy of Copy<IFactRegistryWithMockingSafeDispatcher>;

IFactRegistryWithMockingSafeDispatcherDrop

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeDispatcherDrop of Drop<IFactRegistryWithMockingSafeDispatcher>;

IFactRegistryWithMockingSafeDispatcherSerde

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryWithMockingSafeDispatcherSerde of Serde<IFactRegistryWithMockingSafeDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::fact_registry_interface::IFactRegistryWithMockingSafeDispatcherSerde::deserialize

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

IFactRegistryExternalDispatcherImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryExternalDispatcherImpl of IFactRegistryExternalDispatcherTrait<
    IFactRegistryExternalDispatcher,
>;

Impl functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherImpl::register_fact

fn register_fact(
    self: IFactRegistryExternalDispatcher,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> FactRegistered

IFactRegistryExternalLibraryDispatcherImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryExternalLibraryDispatcherImpl of IFactRegistryExternalDispatcherTrait<
    IFactRegistryExternalLibraryDispatcher,
>;

Impl functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherImpl::register_fact

fn register_fact(
    self: IFactRegistryExternalLibraryDispatcher,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> FactRegistered

IFactRegistryExternalSafeLibraryDispatcherImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryExternalSafeLibraryDispatcherImpl of IFactRegistryExternalSafeDispatcherTrait<
    IFactRegistryExternalSafeLibraryDispatcher,
>;

Impl functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherImpl::register_fact

fn register_fact(
    self: IFactRegistryExternalSafeLibraryDispatcher,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> Result<FactRegistered, Array<felt252>>

IFactRegistryExternalSafeDispatcherImpl

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherImpl

Part of the group: dispatchers

impl IFactRegistryExternalSafeDispatcherImpl of IFactRegistryExternalSafeDispatcherTrait<
    IFactRegistryExternalSafeDispatcher,
>;

Impl functions

register_fact

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherImpl::register_fact

fn register_fact(
    self: IFactRegistryExternalSafeDispatcher,
    verifier_config: VerifierConfiguration,
    fact_hash: felt252,
    security_bits: u32,
) -> Result<FactRegistered, Array<felt252>>

IFactRegistryExternalDispatcherCopy

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryExternalDispatcherCopy of Copy<IFactRegistryExternalDispatcher>;

IFactRegistryExternalDispatcherDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryExternalDispatcherDrop of Drop<IFactRegistryExternalDispatcher>;

IFactRegistryExternalDispatcherSerde

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryExternalDispatcherSerde of Serde<IFactRegistryExternalDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalDispatcherSerde::deserialize

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

IFactRegistryExternalLibraryDispatcherCopy

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryExternalLibraryDispatcherCopy of Copy<IFactRegistryExternalLibraryDispatcher>;

IFactRegistryExternalLibraryDispatcherDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryExternalLibraryDispatcherDrop of Drop<IFactRegistryExternalLibraryDispatcher>;

IFactRegistryExternalLibraryDispatcherSerde

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryExternalLibraryDispatcherSerde of Serde<IFactRegistryExternalLibraryDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalLibraryDispatcherSerde::deserialize

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

IFactRegistryExternalSafeLibraryDispatcherCopy

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryExternalSafeLibraryDispatcherCopy of Copy<
    IFactRegistryExternalSafeLibraryDispatcher,
>;

IFactRegistryExternalSafeLibraryDispatcherDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryExternalSafeLibraryDispatcherDrop of Drop<
    IFactRegistryExternalSafeLibraryDispatcher,
>;

IFactRegistryExternalSafeLibraryDispatcherSerde

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryExternalSafeLibraryDispatcherSerde of Serde<
    IFactRegistryExternalSafeLibraryDispatcher,
>;

Impl functions

serialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeLibraryDispatcherSerde::deserialize

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

IFactRegistryExternalSafeDispatcherCopy

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherCopy

Part of the group: dispatchers

impl IFactRegistryExternalSafeDispatcherCopy of Copy<IFactRegistryExternalSafeDispatcher>;

IFactRegistryExternalSafeDispatcherDrop

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherDrop

Part of the group: dispatchers

impl IFactRegistryExternalSafeDispatcherDrop of Drop<IFactRegistryExternalSafeDispatcher>;

IFactRegistryExternalSafeDispatcherSerde

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherSerde

Part of the group: dispatchers

impl IFactRegistryExternalSafeDispatcherSerde of Serde<IFactRegistryExternalSafeDispatcher>;

Impl functions

serialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherSerde::serialize

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

deserialize

Fully qualified path: integrity::contracts::mocked_fact_registry::IFactRegistryExternalSafeDispatcherSerde::deserialize

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