//! > Test expansion of a simple starknet contract with ownable component.

//! > test_runner_name
ExpandContractFromCrateTestRunner(expect_diagnostics: false)

//! > contract_file_name
cairo_level_tests/contracts/mintable.cairo

//! > generated_cairo_code
#[starknet::interface]
trait GetSupply<TContractState> {
    fn get_total_supply_plus_1(self: @TContractState) -> u256;
}

#[starknet::contract]
mod mintable_erc20_ownable {
    use starknet::ContractAddress;
    use crate::components::erc20::erc20 as erc20_comp;
    use crate::components::mintable::mintable as mintable_comp;
    use crate::components::ownable::ownable as ownable_comp;
    #[storage]
    struct Storage {
        #[substorage(v0)]
        erc20_storage: erc20_comp::Storage,
        #[substorage(v0)]
        ownable_storage: ownable_comp::Storage,
        #[substorage(v0)]
        mintable_storage: mintable_comp::Storage,
    }

    #[event]
    #[derive(Drop, starknet::Event)]
    enum Event {
        ERC20: erc20_comp::Event,
        Ownable: ownable_comp::Event,
        Mintable: mintable_comp::Event,
    }

    #[abi(embed_v0)]
    impl ERC20Impl = erc20_comp::IERC20<ContractState>;

    impl ERC20Helper = erc20_comp::ERC20HelperImpl<ContractState>;

    #[abi(embed_v0)]
    impl OwnershipTransfer = ownable_comp::Transfer<ContractState>;

    impl OwnershipHelper = ownable_comp::OwnableHelperImpl<ContractState>;

    #[abi(embed_v0)]
    impl MintImpl = mintable_comp::Mint<ContractState>;

    #[abi(per_item)]
    #[generate_trait]
    impl ImplCtor of TraitCtor {
        #[constructor]
        fn constructor(
            ref self: ContractState,
            name: felt252,
            symbol: felt252,
            decimals: u8,
            initial_supply: u256,
            recipient: ContractAddress,
            owner: ContractAddress,
        ) {
            self.erc20_storage.init(name, symbol, decimals, initial_supply, recipient);
            self.ownable_storage.init_ownable(owner);
        }
    }

    #[abi(embed_v0)]
    impl ImplGetSupply of super::GetSupply<ContractState> {
        fn get_total_supply_plus_1(self: @ContractState) -> u256 {
            self.erc20_storage.get_total_supply() + 1
        }
    }



#[derive(Drop, Copy)]
#[doc(hidden)]
struct StorageStorageBase {
        #[substorage(v0)]
    erc20_storage: starknet::storage::FlattenedStorage<erc20_comp::Storage>,
        #[substorage(v0)]
    ownable_storage: starknet::storage::FlattenedStorage<ownable_comp::Storage>,
        #[substorage(v0)]
    mintable_storage: starknet::storage::FlattenedStorage<mintable_comp::Storage>,
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        let __erc20_storage_value__ = starknet::storage::FlattenedStorage {};
        let __ownable_storage_value__ = starknet::storage::FlattenedStorage {};
        let __mintable_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBase {
           erc20_storage: __erc20_storage_value__,
           ownable_storage: __ownable_storage_value__,
           mintable_storage: __mintable_storage_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct StorageStorageBaseMut {
        #[substorage(v0)]
    erc20_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<erc20_comp::Storage>>,
        #[substorage(v0)]
    ownable_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<ownable_comp::Storage>>,
        #[substorage(v0)]
    mintable_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<mintable_comp::Storage>>,
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        let __erc20_storage_value__ = starknet::storage::FlattenedStorage {};
        let __ownable_storage_value__ = starknet::storage::FlattenedStorage {};
        let __mintable_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBaseMut {
           erc20_storage: __erc20_storage_value__,
           ownable_storage: __ownable_storage_value__,
           mintable_storage: __mintable_storage_value__,
        }
    }
}

pub struct ContractState {
        #[substorage(v0)]
         erc20_storage: erc20_comp::ComponentState<ContractState>,
        #[substorage(v0)]
         ownable_storage: ownable_comp::ComponentState<ContractState>,
        #[substorage(v0)]
         mintable_storage: mintable_comp::ComponentState<ContractState>,
}

impl ContractStateDrop of Drop<ContractState> {}

impl ContractStateDeref of core::ops::Deref<@ContractState> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ContractState) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ContractStateDerefMut of core::ops::DerefMut<ContractState> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_contract_state() -> ContractState {
    ContractState {
            erc20_storage: erc20_comp::unsafe_new_component_state::<ContractState>(),
            ownable_storage: ownable_comp::unsafe_new_component_state::<ContractState>(),
            mintable_storage: mintable_comp::unsafe_new_component_state::<ContractState>(),
    }
}

// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;

impl ContractStateIERC20 of
    erc20_comp::UnsafeNewContractStateTraitForIERC20<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateTransfer of
    ownable_comp::UnsafeNewContractStateTraitForTransfer<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateMint of
    mintable_comp::UnsafeNewContractStateTraitForMint<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__ImplCtor__constructor(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    let Some(_) = core::gas::withdraw_gas() else {
        core::panic_with_felt252('Out of gas');
    };
    let __arg_name = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<felt252>::deserialize(ref data),
        'Failed to deserialize param #1'
    );
    let __arg_symbol = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<felt252>::deserialize(ref data),
        'Failed to deserialize param #2'
    );
    let __arg_decimals = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<u8>::deserialize(ref data),
        'Failed to deserialize param #3'
    );
    let __arg_initial_supply = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<u256>::deserialize(ref data),
        'Failed to deserialize param #4'
    );
    let __arg_recipient = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<ContractAddress>::deserialize(ref data),
        'Failed to deserialize param #5'
    );
    let __arg_owner = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<ContractAddress>::deserialize(ref data),
        'Failed to deserialize param #6'
    );
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    let Some(_) = core::gas::withdraw_gas_all(core::gas::get_builtin_costs()) else {
        core::panic_with_felt252('Out of gas');
    };
    let mut contract_state = unsafe_new_contract_state();
    ImplCtor::constructor(ref contract_state, __arg_name, __arg_symbol, __arg_decimals, __arg_initial_supply, __arg_recipient, __arg_owner);
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}

#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__ImplGetSupply__get_total_supply_plus_1(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    let Some(_) = core::gas::withdraw_gas() else {
        core::panic_with_felt252('Out of gas');
    };
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    let Some(_) = core::gas::withdraw_gas_all(core::gas::get_builtin_costs()) else {
        core::panic_with_felt252('Out of gas');
    };
    let mut contract_state = unsafe_new_contract_state();
    let res = ImplGetSupply::get_total_supply_plus_1(@contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::serde::Serde::<u256>::serialize(@res, ref arr);
    core::array::ArrayTrait::span(@arr)
}


#[doc(hidden)]
pub mod __external {
    pub use super::__wrapper__ImplGetSupply__get_total_supply_plus_1 as get_total_supply_plus_1;
}
#[doc(hidden)]
pub mod __l1_handler {
}
#[doc(hidden)]
pub mod __constructor {
    pub use super::__wrapper__ImplCtor__constructor as constructor;
}
    impl ContractStateEventEmitter of starknet::event::EventEmitter<
        ContractState, Event
    > {
        fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(
            ref self: ContractState, event: S
        ) {
            let event: Event = core::traits::Into::into(event);
            let mut keys = Default::<core::array::Array>::default();
            let mut data = Default::<core::array::Array>::default();
            starknet::Event::append_keys_and_data(@event, ref keys, ref data);
            starknet::SyscallResultTrait::unwrap_syscall(
                starknet::syscalls::emit_event_syscall(
                    core::array::ArrayTrait::span(@keys),
                    core::array::ArrayTrait::span(@data),
                )
            )
        }
    }

impl HasComponentImpl_erc20_comp of erc20_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @erc20_comp::ComponentState<ContractState> {
                 @erc20_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> erc20_comp::ComponentState<ContractState> {
        erc20_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @erc20_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: erc20_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, erc20_comp::Event>>(ref self: erc20_comp::ComponentState<ContractState>, event: S) {
        let event: erc20_comp::Event = core::traits::Into::into(event);
        let mut contract = erc20_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::ERC20(event));
    }
}
impl HasComponentImpl_ownable_comp of ownable_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @ownable_comp::ComponentState<ContractState> {
                 @ownable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> ownable_comp::ComponentState<ContractState> {
        ownable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @ownable_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: ownable_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, ownable_comp::Event>>(ref self: ownable_comp::ComponentState<ContractState>, event: S) {
        let event: ownable_comp::Event = core::traits::Into::into(event);
        let mut contract = ownable_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::Ownable(event));
    }
}
impl HasComponentImpl_mintable_comp of mintable_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @mintable_comp::ComponentState<ContractState> {
                 @mintable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> mintable_comp::ComponentState<ContractState> {
        mintable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @mintable_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: mintable_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, mintable_comp::Event>>(ref self: mintable_comp::ComponentState<ContractState>, event: S) {
        let event: mintable_comp::Event = core::traits::Into::into(event);
        let mut contract = mintable_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::Mintable(event));
    }
}
impl EventDrop<> of core::traits::Drop::<Event>;
impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
            Event::ERC20(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("ERC20"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
            Event::Ownable(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("Ownable"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
            Event::Mintable(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("Mintable"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        if __selector__ == selector!("ERC20") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::ERC20(val));
        }
        if __selector__ == selector!("Ownable") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::Ownable(val));
        }
        if __selector__ == selector!("Mintable") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::Mintable(val));
        }
        Option::None
    }
}
impl EventERC20IntoEvent of Into<erc20_comp::Event, Event> {
    fn into(self: erc20_comp::Event) -> Event {
        Event::ERC20(self)
    }
}
impl EventOwnableIntoEvent of Into<ownable_comp::Event, Event> {
    fn into(self: ownable_comp::Event) -> Event {
        Event::Ownable(self)
    }
}
impl EventMintableIntoEvent of Into<mintable_comp::Event, Event> {
    fn into(self: mintable_comp::Event) -> Event {
        Event::Mintable(self)
    }
}
    trait TraitCtor {
        #[constructor]
        fn constructor(
            ref self: ContractState,
            name: felt252,
            symbol: felt252,
            decimals: u8,
            initial_supply: u256,
            recipient: ContractAddress,
            owner: ContractAddress,
        );
    }
#[doc(hidden)]
impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
#[doc(hidden)]
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;
}
#[doc(group: "dispatchers")]
trait GetSupplyDispatcherTrait<T> {
    fn get_total_supply_plus_1(self: T) -> u256;
}

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

#[doc(group: "dispatchers")]
impl GetSupplyDispatcherImpl of GetSupplyDispatcherTrait<GetSupplyDispatcher> {
    fn get_total_supply_plus_1(self: GetSupplyDispatcher) -> u256 {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get_total_supply_plus_1"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<u256>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }

}

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

#[doc(group: "dispatchers")]
impl GetSupplyLibraryDispatcherImpl of GetSupplyDispatcherTrait<GetSupplyLibraryDispatcher> {
    fn get_total_supply_plus_1(self: GetSupplyLibraryDispatcher) -> u256 {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get_total_supply_plus_1"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__);
        core::option::OptionTrait::expect(
            core::serde::Serde::<u256>::deserialize(ref __dispatcher_return_data__),
            'Returned data too short',
        )
    }

}

#[doc(group: "dispatchers")]
trait GetSupplySafeDispatcherTrait<T> {
    #[unstable(feature: "safe_dispatcher")]
    fn get_total_supply_plus_1(self: T) -> starknet::SyscallResult<u256>;
}

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

#[doc(group: "dispatchers")]
impl GetSupplySafeLibraryDispatcherImpl of GetSupplySafeDispatcherTrait<GetSupplySafeLibraryDispatcher> {
    fn get_total_supply_plus_1(self: GetSupplySafeLibraryDispatcher) -> starknet::SyscallResult<u256> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall(
            self.class_hash,
            selector!("get_total_supply_plus_1"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<u256>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }

}


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

#[doc(group: "dispatchers")]
impl GetSupplySafeDispatcherImpl of GetSupplySafeDispatcherTrait<GetSupplySafeDispatcher> {
    fn get_total_supply_plus_1(self: GetSupplySafeDispatcher) -> starknet::SyscallResult<u256> {
        let mut __calldata__ = core::traits::Default::default();

        let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall(
            self.contract_address,
            selector!("get_total_supply_plus_1"),
            core::array::ArrayTrait::span(@__calldata__),
        );
        let mut __dispatcher_return_data__ = __dispatcher_return_data__?;
        Result::Ok(
            core::option::OptionTrait::expect(
                core::serde::Serde::<u256>::deserialize(ref __dispatcher_return_data__),
                'Returned data too short',
            )
        )
    }

}
#[doc(group: "dispatchers")]
impl GetSupplyDispatcherCopy<> of core::traits::Copy::<GetSupplyDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplyDispatcherDrop<> of core::traits::Drop::<GetSupplyDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplyDispatcherSerde<> of core::serde::Serde::<GetSupplyDispatcher> {
    fn serialize(self: @GetSupplyDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<GetSupplyDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(GetSupplyDispatcher {
            contract_address: contract_address.value,
        })
    }
}
impl GetSupplyDispatcherStore<> of starknet::Store::<GetSupplyDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<GetSupplyDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            GetSupplyDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: GetSupplyDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let GetSupplyDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<GetSupplyDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            GetSupplyDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: GetSupplyDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let GetSupplyDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplyDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersImpl of starknet::storage::SubPointers<GetSupplyDispatcher> {
    type SubPointersType = GetSupplyDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<GetSupplyDispatcher>) -> GetSupplyDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplyDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplyDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<GetSupplyDispatcher> {
    type SubPointersType = GetSupplyDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<GetSupplyDispatcher>>) -> GetSupplyDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplyDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}
#[doc(group: "dispatchers")]
impl GetSupplyLibraryDispatcherCopy<> of core::traits::Copy::<GetSupplyLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplyLibraryDispatcherDrop<> of core::traits::Drop::<GetSupplyLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplyLibraryDispatcherSerde<> of core::serde::Serde::<GetSupplyLibraryDispatcher> {
    fn serialize(self: @GetSupplyLibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<GetSupplyLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(GetSupplyLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}
impl GetSupplyLibraryDispatcherStore<> of starknet::Store::<GetSupplyLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<GetSupplyLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            GetSupplyLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: GetSupplyLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let GetSupplyLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<GetSupplyLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            GetSupplyLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: GetSupplyLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let GetSupplyLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplyLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<GetSupplyLibraryDispatcher> {
    type SubPointersType = GetSupplyLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<GetSupplyLibraryDispatcher>) -> GetSupplyLibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplyLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplyLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<GetSupplyLibraryDispatcher> {
    type SubPointersType = GetSupplyLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<GetSupplyLibraryDispatcher>>) -> GetSupplyLibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplyLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}
#[doc(group: "dispatchers")]
impl GetSupplySafeLibraryDispatcherCopy<> of core::traits::Copy::<GetSupplySafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplySafeLibraryDispatcherDrop<> of core::traits::Drop::<GetSupplySafeLibraryDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplySafeLibraryDispatcherSerde<> of core::serde::Serde::<GetSupplySafeLibraryDispatcher> {
    fn serialize(self: @GetSupplySafeLibraryDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ClassHash>::serialize(self.class_hash, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<GetSupplySafeLibraryDispatcher> {
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: core::serde::Serde::<starknet::ClassHash>::deserialize(ref serialized)? };
        core::option::Option::Some(GetSupplySafeLibraryDispatcher {
            class_hash: class_hash.value,
        })
    }
}
impl GetSupplySafeLibraryDispatcherStore<> of starknet::Store::<GetSupplySafeLibraryDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<GetSupplySafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            GetSupplySafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: GetSupplySafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let GetSupplySafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write(__store_derive_address_domain__, __store_derive_base__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<GetSupplySafeLibraryDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: starknet::Store::<starknet::ClassHash>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            GetSupplySafeLibraryDispatcher {
                class_hash: class_hash.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: GetSupplySafeLibraryDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let GetSupplySafeLibraryDispatcher {
            class_hash,
        } = value;
        let class_hash = core::internal::InferDestruct::<starknet::ClassHash> { value: class_hash };
        starknet::Store::<starknet::ClassHash>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, class_hash.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ClassHash>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplySafeLibraryDispatcherSubPointers {
    pub class_hash: starknet::storage::StoragePointer<starknet::ClassHash>,
}
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers<GetSupplySafeLibraryDispatcher> {
    type SubPointersType = GetSupplySafeLibraryDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<GetSupplySafeLibraryDispatcher>) -> GetSupplySafeLibraryDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplySafeLibraryDispatcherSubPointers {
           class_hash: __class_hash_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplySafeLibraryDispatcherSubPointersMut {
    pub class_hash: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ClassHash>>,
}
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<GetSupplySafeLibraryDispatcher> {
    type SubPointersType = GetSupplySafeLibraryDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<GetSupplySafeLibraryDispatcher>>) -> GetSupplySafeLibraryDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __class_hash_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplySafeLibraryDispatcherSubPointersMut {
           class_hash: __class_hash_value__,
        }
    }
}
#[doc(group: "dispatchers")]
impl GetSupplySafeDispatcherCopy<> of core::traits::Copy::<GetSupplySafeDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplySafeDispatcherDrop<> of core::traits::Drop::<GetSupplySafeDispatcher>;
#[doc(group: "dispatchers")]
impl GetSupplySafeDispatcherSerde<> of core::serde::Serde::<GetSupplySafeDispatcher> {
    fn serialize(self: @GetSupplySafeDispatcher, ref output: core::array::Array<felt252>) {
        core::serde::Serde::<starknet::ContractAddress>::serialize(self.contract_address, ref output)
    }
    fn deserialize(ref serialized: core::array::Span<felt252>) -> core::option::Option<GetSupplySafeDispatcher> {
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: core::serde::Serde::<starknet::ContractAddress>::deserialize(ref serialized)? };
        core::option::Option::Some(GetSupplySafeDispatcher {
            contract_address: contract_address.value,
        })
    }
}
impl GetSupplySafeDispatcherStore<> of starknet::Store::<GetSupplySafeDispatcher> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<GetSupplySafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            GetSupplySafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: GetSupplySafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let GetSupplySafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write(__store_derive_address_domain__, __store_derive_base__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<GetSupplySafeDispatcher> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: starknet::Store::<starknet::ContractAddress>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            GetSupplySafeDispatcher {
                contract_address: contract_address.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: GetSupplySafeDispatcher) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let GetSupplySafeDispatcher {
            contract_address,
        } = value;
        let contract_address = core::internal::InferDestruct::<starknet::ContractAddress> { value: contract_address };
        starknet::Store::<starknet::ContractAddress>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, contract_address.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<starknet::ContractAddress>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplySafeDispatcherSubPointers {
    pub contract_address: starknet::storage::StoragePointer<starknet::ContractAddress>,
}
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersImpl of starknet::storage::SubPointers<GetSupplySafeDispatcher> {
    type SubPointersType = GetSupplySafeDispatcherSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<GetSupplySafeDispatcher>) -> GetSupplySafeDispatcherSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplySafeDispatcherSubPointers {
           contract_address: __contract_address_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct GetSupplySafeDispatcherSubPointersMut {
    pub contract_address: starknet::storage::StoragePointer<starknet::storage::Mutable::<starknet::ContractAddress>>,
}
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut<GetSupplySafeDispatcher> {
    type SubPointersType = GetSupplySafeDispatcherSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<GetSupplySafeDispatcher>>) -> GetSupplySafeDispatcherSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __contract_address_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                GetSupplySafeDispatcherSubPointersMut {
           contract_address: __contract_address_value__,
        }
    }
}
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersDrop<> of core::traits::Drop::<GetSupplyDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersCopy<> of core::traits::Copy::<GetSupplyDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersMutDrop<> of core::traits::Drop::<GetSupplyDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplyDispatcherSubPointersMutCopy<> of core::traits::Copy::<GetSupplyDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<GetSupplyLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<GetSupplyLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<GetSupplyLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplyLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<GetSupplyLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersDrop<> of core::traits::Drop::<GetSupplySafeLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersCopy<> of core::traits::Copy::<GetSupplySafeLibraryDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersMutDrop<> of core::traits::Drop::<GetSupplySafeLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplySafeLibraryDispatcherSubPointersMutCopy<> of core::traits::Copy::<GetSupplySafeLibraryDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersDrop<> of core::traits::Drop::<GetSupplySafeDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersCopy<> of core::traits::Copy::<GetSupplySafeDispatcherSubPointers>;
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersMutDrop<> of core::traits::Drop::<GetSupplySafeDispatcherSubPointersMut>;
#[doc(hidden)]
impl GetSupplySafeDispatcherSubPointersMutCopy<> of core::traits::Copy::<GetSupplySafeDispatcherSubPointersMut>;

    use starknet::ContractAddress;
    use crate::components::erc20::erc20 as erc20_comp;
    use crate::components::mintable::mintable as mintable_comp;
    use crate::components::ownable::ownable as ownable_comp;
    #[storage]
    struct Storage {
        #[substorage(v0)]
        erc20_storage: erc20_comp::Storage,
        #[substorage(v0)]
        ownable_storage: ownable_comp::Storage,
        #[substorage(v0)]
        mintable_storage: mintable_comp::Storage,
    }

    #[event]
    #[derive(Drop, starknet::Event)]
    enum Event {
        ERC20: erc20_comp::Event,
        Ownable: ownable_comp::Event,
        Mintable: mintable_comp::Event,
    }

    #[abi(embed_v0)]
    impl ERC20Impl = erc20_comp::IERC20<ContractState>;

    impl ERC20Helper = erc20_comp::ERC20HelperImpl<ContractState>;

    #[abi(embed_v0)]
    impl OwnershipTransfer = ownable_comp::Transfer<ContractState>;

    impl OwnershipHelper = ownable_comp::OwnableHelperImpl<ContractState>;

    #[abi(embed_v0)]
    impl MintImpl = mintable_comp::Mint<ContractState>;

    #[abi(per_item)]
    #[generate_trait]
    impl ImplCtor of TraitCtor {
        #[constructor]
        fn constructor(
            ref self: ContractState,
            name: felt252,
            symbol: felt252,
            decimals: u8,
            initial_supply: u256,
            recipient: ContractAddress,
            owner: ContractAddress,
        ) {
            self.erc20_storage.init(name, symbol, decimals, initial_supply, recipient);
            self.ownable_storage.init_ownable(owner);
        }
    }

    #[abi(embed_v0)]
    impl ImplGetSupply of super::GetSupply<ContractState> {
        fn get_total_supply_plus_1(self: @ContractState) -> u256 {
            self.erc20_storage.get_total_supply() + 1
        }
    }



#[derive(Drop, Copy)]
#[doc(hidden)]
struct StorageStorageBase {
        #[substorage(v0)]
    erc20_storage: starknet::storage::FlattenedStorage<erc20_comp::Storage>,
        #[substorage(v0)]
    ownable_storage: starknet::storage::FlattenedStorage<ownable_comp::Storage>,
        #[substorage(v0)]
    mintable_storage: starknet::storage::FlattenedStorage<mintable_comp::Storage>,
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        let __erc20_storage_value__ = starknet::storage::FlattenedStorage {};
        let __ownable_storage_value__ = starknet::storage::FlattenedStorage {};
        let __mintable_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBase {
           erc20_storage: __erc20_storage_value__,
           ownable_storage: __ownable_storage_value__,
           mintable_storage: __mintable_storage_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
struct StorageStorageBaseMut {
        #[substorage(v0)]
    erc20_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<erc20_comp::Storage>>,
        #[substorage(v0)]
    ownable_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<ownable_comp::Storage>>,
        #[substorage(v0)]
    mintable_storage: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<mintable_comp::Storage>>,
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        let __erc20_storage_value__ = starknet::storage::FlattenedStorage {};
        let __ownable_storage_value__ = starknet::storage::FlattenedStorage {};
        let __mintable_storage_value__ = starknet::storage::FlattenedStorage {};
        StorageStorageBaseMut {
           erc20_storage: __erc20_storage_value__,
           ownable_storage: __ownable_storage_value__,
           mintable_storage: __mintable_storage_value__,
        }
    }
}

pub struct ContractState {
        #[substorage(v0)]
         erc20_storage: erc20_comp::ComponentState<ContractState>,
        #[substorage(v0)]
         ownable_storage: ownable_comp::ComponentState<ContractState>,
        #[substorage(v0)]
         mintable_storage: mintable_comp::ComponentState<ContractState>,
}

impl ContractStateDrop of Drop<ContractState> {}

impl ContractStateDeref of core::ops::Deref<@ContractState> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ContractState) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ContractStateDerefMut of core::ops::DerefMut<ContractState> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_contract_state() -> ContractState {
    ContractState {
            erc20_storage: erc20_comp::unsafe_new_component_state::<ContractState>(),
            ownable_storage: ownable_comp::unsafe_new_component_state::<ContractState>(),
            mintable_storage: mintable_comp::unsafe_new_component_state::<ContractState>(),
    }
}

// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;

impl ContractStateIERC20 of
    erc20_comp::UnsafeNewContractStateTraitForIERC20<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateTransfer of
    ownable_comp::UnsafeNewContractStateTraitForTransfer<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
impl ContractStateMint of
    mintable_comp::UnsafeNewContractStateTraitForMint<ContractState> {
    fn unsafe_new_contract_state() -> ContractState {
        unsafe_new_contract_state()
    }
}
#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__ImplCtor__constructor(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    let Some(_) = core::gas::withdraw_gas() else {
        core::panic_with_felt252('Out of gas');
    };
    let __arg_name = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<felt252>::deserialize(ref data),
        'Failed to deserialize param #1'
    );
    let __arg_symbol = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<felt252>::deserialize(ref data),
        'Failed to deserialize param #2'
    );
    let __arg_decimals = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<u8>::deserialize(ref data),
        'Failed to deserialize param #3'
    );
    let __arg_initial_supply = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<u256>::deserialize(ref data),
        'Failed to deserialize param #4'
    );
    let __arg_recipient = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<ContractAddress>::deserialize(ref data),
        'Failed to deserialize param #5'
    );
    let __arg_owner = core::option::OptionTraitImpl::expect(
        core::serde::Serde::<ContractAddress>::deserialize(ref data),
        'Failed to deserialize param #6'
    );
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    let Some(_) = core::gas::withdraw_gas_all(core::gas::get_builtin_costs()) else {
        core::panic_with_felt252('Out of gas');
    };
    let mut contract_state = unsafe_new_contract_state();
    ImplCtor::constructor(ref contract_state, __arg_name, __arg_symbol, __arg_decimals, __arg_initial_supply, __arg_recipient, __arg_owner);
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::array::ArrayTrait::span(@arr)
}

#[doc(hidden)]
#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
fn __wrapper__ImplGetSupply__get_total_supply_plus_1(mut data: Span::<felt252>) -> Span::<felt252> {
    core::internal::require_implicit::<System>();
    core::internal::revoke_ap_tracking();
    let Some(_) = core::gas::withdraw_gas() else {
        core::panic_with_felt252('Out of gas');
    };
    
    assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments');
    let Some(_) = core::gas::withdraw_gas_all(core::gas::get_builtin_costs()) else {
        core::panic_with_felt252('Out of gas');
    };
    let mut contract_state = unsafe_new_contract_state();
    let res = ImplGetSupply::get_total_supply_plus_1(@contract_state, );
    let mut arr = ArrayTrait::new();
    // References.
    // Result.
    core::serde::Serde::<u256>::serialize(@res, ref arr);
    core::array::ArrayTrait::span(@arr)
}


#[doc(hidden)]
pub mod __external {
    pub use super::__wrapper__ImplGetSupply__get_total_supply_plus_1 as get_total_supply_plus_1;
}
#[doc(hidden)]
pub mod __l1_handler {
}
#[doc(hidden)]
pub mod __constructor {
    pub use super::__wrapper__ImplCtor__constructor as constructor;
}
    impl ContractStateEventEmitter of starknet::event::EventEmitter<
        ContractState, Event
    > {
        fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(
            ref self: ContractState, event: S
        ) {
            let event: Event = core::traits::Into::into(event);
            let mut keys = Default::<core::array::Array>::default();
            let mut data = Default::<core::array::Array>::default();
            starknet::Event::append_keys_and_data(@event, ref keys, ref data);
            starknet::SyscallResultTrait::unwrap_syscall(
                starknet::syscalls::emit_event_syscall(
                    core::array::ArrayTrait::span(@keys),
                    core::array::ArrayTrait::span(@data),
                )
            )
        }
    }

impl HasComponentImpl_erc20_comp of erc20_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @erc20_comp::ComponentState<ContractState> {
                 @erc20_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> erc20_comp::ComponentState<ContractState> {
        erc20_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @erc20_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: erc20_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, erc20_comp::Event>>(ref self: erc20_comp::ComponentState<ContractState>, event: S) {
        let event: erc20_comp::Event = core::traits::Into::into(event);
        let mut contract = erc20_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::ERC20(event));
    }
}
impl HasComponentImpl_ownable_comp of ownable_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @ownable_comp::ComponentState<ContractState> {
                 @ownable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> ownable_comp::ComponentState<ContractState> {
        ownable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @ownable_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: ownable_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, ownable_comp::Event>>(ref self: ownable_comp::ComponentState<ContractState>, event: S) {
        let event: ownable_comp::Event = core::traits::Into::into(event);
        let mut contract = ownable_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::Ownable(event));
    }
}
impl HasComponentImpl_mintable_comp of mintable_comp::HasComponent<ContractState> {
    fn get_component(self: @ContractState) -> @mintable_comp::ComponentState<ContractState> {
                 @mintable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_component_mut(ref self: ContractState) -> mintable_comp::ComponentState<ContractState> {
        mintable_comp::unsafe_new_component_state::<ContractState>()
    }
    fn get_contract(self: @mintable_comp::ComponentState<ContractState>) -> @ContractState {
        @unsafe_new_contract_state()
    }
    fn get_contract_mut(ref self: mintable_comp::ComponentState<ContractState>) -> ContractState {
        unsafe_new_contract_state()
    }
    fn emit<S, impl IntoImp: core::traits::Into<S, mintable_comp::Event>>(ref self: mintable_comp::ComponentState<ContractState>, event: S) {
        let event: mintable_comp::Event = core::traits::Into::into(event);
        let mut contract = mintable_comp::HasComponent::get_contract_mut(ref self);
        ContractStateEventEmitter::emit(ref contract, Event::Mintable(event));
    }
}
impl EventDrop<> of core::traits::Drop::<Event>;
impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
            Event::ERC20(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("ERC20"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
            Event::Ownable(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("Ownable"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
            Event::Mintable(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("Mintable"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        if __selector__ == selector!("ERC20") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::ERC20(val));
        }
        if __selector__ == selector!("Ownable") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::Ownable(val));
        }
        if __selector__ == selector!("Mintable") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::Mintable(val));
        }
        Option::None
    }
}
impl EventERC20IntoEvent of Into<erc20_comp::Event, Event> {
    fn into(self: erc20_comp::Event) -> Event {
        Event::ERC20(self)
    }
}
impl EventOwnableIntoEvent of Into<ownable_comp::Event, Event> {
    fn into(self: ownable_comp::Event) -> Event {
        Event::Ownable(self)
    }
}
impl EventMintableIntoEvent of Into<mintable_comp::Event, Event> {
    fn into(self: mintable_comp::Event) -> Event {
        Event::Mintable(self)
    }
}
    trait TraitCtor {
        #[constructor]
        fn constructor(
            ref self: ContractState,
            name: felt252,
            symbol: felt252,
            decimals: u8,
            initial_supply: u256,
            recipient: ContractAddress,
            owner: ContractAddress,
        );
    }
#[doc(hidden)]
impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
#[doc(hidden)]
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;

//! > expected_diagnostics
