Merge pull request #13 from aji70/main

feat: Implement Account Creation Functions closes #5

Author: Pvsaint

.tool-versions

@@ -1,2 +1,2 @@
 scarb 2.8.4
-starknet-foundry 0.32.0
+starknet-foundry 0.39.0

src/base/types.cairo

@@ -1 +1,11 @@
-
+use starknet::ContractAddress;
+#[derive(Drop, Serde, starknet::Store)]
+pub struct TokenBoundAccount {
+    pub id: u256,
+    pub address: ContractAddress,
+    pub user_name: felt252,
+    pub init_param1: felt252,
+    pub init_param2: felt252,
+    pub created_at: u64,
+    pub updated_at: u64,
+}

src/chainlib/ChainLib.cairo

@@ -1 +1,90 @@
+#[starknet::contract]
+pub mod ChainLib {
+    use starknet::storage::{
+        Map, StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess,
+        StoragePointerWriteAccess,
+    };
+    use starknet::{ContractAddress, get_block_timestamp, get_caller_address};
+    use crate::interfaces::IChainLib::IChainLib;
+    use crate::base::types::{TokenBoundAccount};
 
+
+    #[storage]
+    struct Storage {
+        // Contract addresses for component management
+        deployed: bool,
+        current_account_id: u256,
+        accounts: Map<u256, TokenBoundAccount>,
+        accountsaddr: Map<ContractAddress, TokenBoundAccount>,
+        next_course_id: u256,
+        nuum: Map<u8, u8>,
+    }
+
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {
+        // Store the values in contract state
+        self.deployed.write(true);
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        TokenBountAccountcreated: TokenBountAccountcreated,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct TokenBountAccountcreated {
+        pub id: u256,
+    }
+
+    #[abi(embed_v0)]
+    impl ChainLibNetImpl of IChainLib<ContractState> {
+        fn create_token_account(
+            ref self: ContractState, user_name: felt252, init_param1: felt252, init_param2: felt252,
+        ) -> u256 {
+            // Validate input parameters.
+            assert!(user_name != 0, "User name cannot be empty");
+            assert!(init_param1 != 0, "Initialization parameter 1 cannot be empty");
+
+            // Retrieve the current account ID before incrementing.
+            let account_id = self.current_account_id.read();
+
+            // Create a new token bound account struct.
+            let new_token_bound_account = TokenBoundAccount {
+                id: account_id,
+                address: get_caller_address(),
+                user_name: user_name,
+                init_param1: init_param1,
+                init_param2: init_param2,
+                created_at: get_block_timestamp(),
+                updated_at: get_block_timestamp(),
+            };
+
+            // Store the new account in the accounts map.
+            self.accounts.write(account_id, new_token_bound_account);
+
+            // Increment the account ID counter after using the current value.
+            self.current_account_id.write(account_id + 1);
+
+            // Emit an event to signal the creation of the token bound account.
+            self.emit(TokenBountAccountcreated { id: account_id });
+
+            account_id
+        }
+
+        fn get_token_bound_account(ref self: ContractState, id: u256) -> TokenBoundAccount {
+            let token_bound_account = self.accounts.read(id);
+            token_bound_account
+        }
+        fn get_token_bound_account_by_owner(
+            ref self: ContractState, address: ContractAddress
+        ) -> TokenBoundAccount {
+            let token_bound_account = self.accountsaddr.read(address);
+            token_bound_account
+        }
+        fn test_deployment(ref self: ContractState) -> bool {
+            self.deployed.read()
+        }
+    }
+}

src/interfaces/IChainLib.cairo

@@ -1 +1,16 @@
+use starknet::ContractAddress;
+use crate::base::types::{TokenBoundAccount};
 
+#[starknet::interface]
+pub trait IChainLib<TContractState> {
+    // Course Management
+    fn create_token_account(
+        ref self: TContractState, user_name: felt252, init_param1: felt252, init_param2: felt252,
+    ) -> u256;
+
+    fn get_token_bound_account(ref self: TContractState, id: u256) -> TokenBoundAccount;
+    fn get_token_bound_account_by_owner(
+        ref self: TContractState, address: ContractAddress
+    ) -> TokenBoundAccount;
+    fn test_deployment(ref self: TContractState) -> bool;
+}

src/lib.cairo

@@ -1,3 +1,11 @@
+pub mod base {
+    pub mod errors;
+    pub mod types;
+}
 pub mod chainlib {
     pub mod ChainLib;
 }
+pub mod interfaces {
+    pub mod IChainLib;
+}
+

tests/lib.cairo

@@ -0,0 +1,3 @@
+#[cfg(test)]
+pub mod test_ChainLib;
+

tests/test_ChainLib.cairo

@@ -1 +1,61 @@
+// Import the contract modules
+use chain_lib::chainlib::ChainLib;
 
+use chain_lib::interfaces::IChainLib::{IChainLib, IChainLibDispatcher, IChainLibDispatcherTrait};
+use snforge_std::{CheatSpan, ContractClassTrait, DeclareResultTrait, cheat_caller_address, declare};
+use starknet::ContractAddress;
+use starknet::class_hash::ClassHash;
+use starknet::contract_address::contract_address_const;
+use starknet::testing::{set_caller_address, set_contract_address};
+
+
+fn setup() -> ContractAddress {
+    let declare_result = declare("ChainLib");
+    assert(declare_result.is_ok(), 'Contract declaration failed');
+
+    let contract_class = declare_result.unwrap().contract_class();
+    let mut calldata = array![];
+
+    let deploy_result = contract_class.deploy(@calldata);
+    assert(deploy_result.is_ok(), 'Contract deployment failed');
+
+    let (contract_address, _) = deploy_result.unwrap();
+
+    (contract_address)
+}
+
+#[test]
+fn test_initial_data() {
+    let contract_address = setup();
+
+    let dispatcher = IChainLibDispatcher { contract_address };
+
+    // Ensure dispatcher methods exist
+    let deployed = dispatcher.test_deployment();
+
+    assert(deployed == true, 'deployment failed');
+}
+
+
+#[test]
+fn test_create_token_bount_account() {
+    let contract_address = setup();
+    let dispatcher = IChainLibDispatcher { contract_address };
+
+    // Test input values
+    let user_name: felt252 = 'John';
+    let init_param1: felt252 = '[email protected]';
+    let init_param2: felt252 = 'john is a boy';
+
+    // Call create_claim
+    let account_id = dispatcher.create_token_account(user_name, init_param1, init_param2);
+
+    // Validate that the claim ID is correctly incremented
+    assert(account_id == 0, 'account_id should start from 0');
+
+    // Retrieve the claim to verify it was stored correctly
+    let token_bound_account = dispatcher.get_token_bound_account(account_id);
+    assert(token_bound_account.user_name == user_name, 'namemismatch');
+    assert(token_bound_account.init_param1 == init_param1, 'init_param1 mismatch');
+    assert(token_bound_account.init_param2 == init_param2, 'init_param2 mismatch');
+}