move initializer to certificate component

Author: aradix16

backend-sc/save.cairo

@@ -0,0 +1,111 @@
+
+    //use openzeppelin::token::erc721::interface::{ERC721ABIDispatcher, ERC721ABIDispatcherTrait};
+#[starknet::component]
+mod NFTComponent {
+    use starknet::ContractAddress;
+
+    use carbon_locker::components::certificate::interface::INFTComponent;
+
+    use openzeppelin::introspection::src5::SRC5Component;
+    use openzeppelin::token::erc721::{
+        ERC721Component,
+        ERC721Component::ERC721Impl,
+        ERC721Component::InternalTrait,
+    };
+
+    use openzeppelin::token::erc721::interface::{ERC721ABIDispatcher, ERC721ABIDispatcherTrait};
+
+    #[storage]
+    struct Storage {
+        wrapped_token: ERC721ABIDispatcher,
+    }
+
+    #[embeddable_as(NFTComponentImpl)]
+    impl NFTComponent< 
+        TContractState,
+        +HasComponent<TContractState>,
+        +Drop<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        impl ERC721: ERC721Component::HasComponent<TContractState>,
+        > of INFTComponent<ComponentState<TContractState>> {
+
+            fn initialize(
+            ref self: ComponentState<TContractState>,
+            name: ByteArray,
+            symbol: ByteArray,
+            base_uri: ByteArray
+        ) {
+                let mut erc721_comp = get_dep_component_mut!(ref self, ERC721);
+                erc721_comp.initializer(name, symbol, base_uri);
+            }
+
+            fn mint(ref self: ComponentState<TContractState>, to: ContractAddress, token_id: u256) {
+                let mut erc721 = get_dep_component_mut!(ref self, ERC721);
+                erc721._mint(to, token_id);
+            }
+
+        }
+}
+
+
+
+
+
+//fn balance_of(self: @ComponentState<TContractState>, account: ContractAddress) -> u256 {
+//  self.wrapped_token.read().balance_of(account)
+//}
+
+
+
+
+use starknet::ContractAddress;
+
+#[starknet::contract]
+mod NFTCertificate {
+    use starknet::ContractAddress;
+
+    use openzeppelin::token::erc721::interface::{IERC721Dispatcher, IERC721DispatcherTrait};
+
+    use carbon_locker::components::certificate::certificate::NFTComponent;
+
+    use openzeppelin::token::erc721::ERC721Component;
+    use openzeppelin::introspection::src5::SRC5Component;
+
+    component!(path: NFTComponent, storage: nft_component, event: NFTComponentEvent);
+    component!(path: ERC721Component, storage: erc721, event: ERC721Event);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+
+    #[abi(embed_v0)]
+    impl ERC721MixinImpl = ERC721Component::ERC721MixinImpl<ContractState>;
+    impl ERC721MetadataImpl = ERC721Component::ERC721MetadataImpl<ContractState>;
+    impl ERC721InternalImpl = ERC721Component::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl NFTComponentImpl = NFTComponent::NFTComponentImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        nft_component: NFTComponent::Storage,
+        #[substorage(v0)]
+        erc721: ERC721Component::Storage,
+        #[substorage(v0)]
+        src5: SRC5Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        NFTComponentEvent: NFTComponent::Event,
+        #[flat]
+        ERC721Event: ERC721Component::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {
+        self.initialize("Certificate", "CERT", "");
+    }
+}

backend-sc/src/components/certificate/certificate.cairo

@@ -21,10 +21,21 @@ mod NFTComponent {
         +Drop<TContractState>,
         +SRC5Component::HasComponent<TContractState>,
         impl ERC721: ERC721Component::HasComponent<TContractState>,
-    > of INFTComponent<ComponentState<TContractState>> {
-        fn mint(ref self: ComponentState<TContractState>, to: ContractAddress, token_id: u256) {
-            let mut erc721 = get_dep_component_mut!(ref self, ERC721);
-            erc721._mint(to, token_id);
+        > of INFTComponent<ComponentState<TContractState>> {
+
+            fn initializer(
+                ref self: ComponentState<TContractState>,
+                name: ByteArray,
+                symbol: ByteArray,
+                base_uri: ByteArray
+            ) {
+                let mut erc721_comp = get_dep_component_mut!(ref self, ERC721);
+                erc721_comp.initializer(name, symbol, base_uri);
+            }
+
+            fn mint(ref self: ComponentState<TContractState>, to: ContractAddress, token_id: u256) {
+                let mut erc721 = get_dep_component_mut!(ref self, ERC721);
+                erc721._mint(to, token_id);
+            }
         }
-    }
 }

backend-sc/src/components/certificate/interface.cairo

@@ -2,5 +2,6 @@ use starknet::ContractAddress;
 
 #[starknet::interface]
 trait INFTComponent<TContractState> {
+    fn initializer(ref self: TContractState, name: ByteArray, symbol: ByteArray, base_uri: ByteArray);
     fn mint(ref self: TContractState, to: ContractAddress, token_id: u256);
 }

backend-sc/src/contracts/certificate.cairo

@@ -1,7 +1,7 @@
 use starknet::ContractAddress;
 
 #[starknet::contract]
-mod Certificate {
+mod NFTCertificate {
     use starknet::ContractAddress;
 
     use carbon_locker::components::certificate::certificate::NFTComponent;
@@ -15,11 +15,10 @@ mod Certificate {
 
     #[abi(embed_v0)]
     impl ERC721MixinImpl = ERC721Component::ERC721MixinImpl<ContractState>;
-    impl ERC721MetadataImpl = ERC721Component::ERC721MetadataImpl<ContractState>;
     impl ERC721InternalImpl = ERC721Component::InternalImpl<ContractState>;
 
     #[abi(embed_v0)]
-    impl CounterImpl = NFTComponent::NFTComponentImpl<ContractState>;
+    impl NFTComponentImpl = NFTComponent::NFTComponentImpl<ContractState>;
 
     #[storage]
     struct Storage {
@@ -44,11 +43,6 @@ mod Certificate {
 
     #[constructor]
     fn constructor(ref self: ContractState) {
-        let name = "Certificate";
-        let symbol = "CERT";
-        let base_uri = "";
-        
-        self.erc721.initializer(name, symbol, base_uri);
+        self.initializer("Certificate", "CERT", "");
     }
 }
-

backend-sc/tests/lib.cairo

@@ -1,2 +1,2 @@
-mod tests_locker;
+//mod tests_locker;
 mod tests_certificate;

backend-sc/tests/tests_certificate.cairo

@@ -1,16 +1,5 @@
 use starknet::{ContractAddress, contract_address_const, get_caller_address};
 
-use openzeppelin::token::erc721::interface::IERC721;
-//use openzeppelin::token::erc721::interface::{IERC721Dispatcher, IERC721DispatcherTrait};
-
-use openzeppelin::token::erc721::interface::{
-    IERC721Dispatcher,
-    IERC721DispatcherTrait,
-    IERC721Metadata,
-    IERC721MetadataDispatcher,
-    IERC721MetadataDispatcherTrait
-};
-
 use snforge_std as snf;
 use snforge_std::{
     ContractClassTrait, EventSpy, start_cheat_caller_address, stop_cheat_caller_address, spy_events,
@@ -21,45 +10,49 @@ use carbon_locker::components::certificate::interface::{
     INFTComponent, INFTComponentDispatcher, INFTComponentDispatcherTrait
 };
 
-use carbon_locker::contracts::certificate::Certificate;
+use carbon_locker::contracts::certificate::NFTCertificate;
+
+use openzeppelin::token::erc721::interface::IERC721;
+
+use openzeppelin::token::erc721::interface::{
+    IERC721Dispatcher,
+    IERC721DispatcherTrait,
+    IERC721Metadata,
+    IERC721MetadataDispatcher,
+    IERC721MetadataDispatcherTrait
+};
 
 fn deploy_nft_certificate() -> ContractAddress {
-    let contract = snf::declare("Certificate").expect('Declaration failed');
+    let contract = snf::declare("NFTCertificate").expect('Declaration failed');
 
     let mut calldata: Array<felt252> = array![];
+    let (contract_address, _) = contract.deploy(@calldata).expect('Certificate deployment failed');
 
-    let (contract_address, _) = contract.deploy(@calldata).expect('NFT deployment failed');
     contract_address
 }
 
 #[test]
 fn test_proper_initialization() {
     let certificate_address = deploy_nft_certificate();
     let user_address: ContractAddress = contract_address_const::<'USER'>();
-    start_cheat_caller_address(certificate_address, user_address);
     let erc721 = IERC721Dispatcher { contract_address: certificate_address };
     let erc721_metadata = IERC721MetadataDispatcher { contract_address: certificate_address };
 
-    let name = erc721_metadata.name();
-    assert(name == "Certificate", 'Name should be Certificate');
-    let symbol = erc721_metadata.symbol();
-    assert(symbol == "CERT", 'Symbol should be CERT');
-
-    let balance = erc721.balance_of(user_address);
+    let mut balance = erc721.balance_of(user_address);
     assert(balance == 0, 'Balance should be 0');
+
+    let name = erc721_metadata.name();
+    assert(name == "Certificate", 'Token name mismatch');
 }
 
 #[test]
-fn test_mint() {
+fn test_mint_function() {
     let certificate_address = deploy_nft_certificate();
-    let erc721 = IERC721Dispatcher { contract_address: certificate_address };
+    let certificate = INFTComponentDispatcher { contract_address: certificate_address };
     let user_address: ContractAddress = contract_address_const::<'USER'>();
-    start_cheat_caller_address(certificate_address, user_address);
-
-    let nft_component = INFTComponentDispatcher { contract_address: certificate_address };
-    let nft_id = 1;
-    nft_component.mint(user_address, nft_id);
+    let erc721 = IERC721Dispatcher { contract_address: certificate_address };
 
-    let balance = erc721.balance_of(user_address);
+    certificate.mint(user_address, 1);
+    let mut balance = erc721.balance_of(user_address);
     assert(balance == 1, 'Balance should be 1');
 }