add dependency examples

Author: ArielElp

README.md

@@ -1 +1,25 @@
-# component-examples
+# component-examples
+
+This repo contains a few examples of the potential interaction between components. For a review on components, see the [community forum post](https://community.starknet.io/t/cairo-components/101136). Build with `scarb build --workspace`, or a specific package via `scarb build --package dependency3`.
+
+## Examples in the repo
+
+### basic_component 
+
+An example of a basic upgradability component with no dependency
+
+### dependency1
+
+Upgradable depends on an `OwnableTrait` implementation to limit access to the `upgrade` function. The contract which uses the component directly implements `OwnableTrait` in order to use the upgradability component.
+
+### dependency2
+
+We now have two components, `Ownable` and `Upgradable`. `Ownable` has the internal function `initialize_owner`, and two external functions that are defined in the `IOwnable` interface. `Upgradable` depends on the contract implementing `IOwnable` to limit to the `upgrade` function. The contract uses both components. By using `Ownable`, we create an impl of `IOwnable<ContractState>`, which is need to use `Upgradable`.
+
+### dependency3
+
+Same as above, but now the `is_owner` function is moved to the internal trait `OwnableInternal`. This means that we need to access "internal" functions (i.e. functions in a none embeddable impl) of component A inside component B. 
+
+Since both `upgrade` and `is_owner` are now functions that expect `upgradable::ComponentState` and `ownable:ComponentState` respectively, we need a way to move from one to the other. To do this, we add a dependency on an implementation of `ownable::HasComponent<TContractState>` to `UpgradableImpl`. This allows us to do the following transition: `upgradable::ComponentState<TContractState>` &rarr; `TcontractState` &rarr; `ownable::ComponentState<TContractState>`.
+
+In order to keep the `upgrade` function brief, we placed this transition logic inside a new impl called `GetOwnable`.

basic_component/scarb.toml

@@ -0,0 +1,10 @@
+[package]
+name = "basic_component"
+version = "0.1.0"
+
+[[target.starknet-contract]]
+allowed-libfuncs-list.name = "audited"
+casm = true
+
+[dependencies]
+starknet = ">=2.3.0-rc0"

basic_component/src/counter_contract.cairo

@@ -0,0 +1,65 @@
+#[starknet::interface]
+trait ICounterContract<TContractState> {
+    fn increase_counter(ref self: TContractState, amount: u128);
+    fn decrease_counter(ref self: TContractState, amount: u128);
+    fn get_counter(self: @TContractState) -> u128;
+}
+
+#[starknet::contract]
+mod counter_contract {
+    use basic_component::upgradable::upgradable as upgradable_component;
+
+    component!(path: upgradable_component, storage: upgradable, event: UpgradableEvent);
+
+    #[abi(embed_v0)]
+    impl Upgradable = upgradable_component::UpgradableImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        counter: u128,
+        #[substorage(v0)]
+        upgradable: upgradable_component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        CounterIncreased: CounterIncreased,
+        CounterDecreased: CounterDecreased,
+        UpgradableEvent: upgradable_component::Event
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct CounterIncreased {
+        amount: u128
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct CounterDecreased {
+        amount: u128
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, initial_counter: u128) {
+        self.counter.write(initial_counter);
+    }
+
+    #[external(v0)]
+    impl CounterContract of super::ICounterContract<ContractState> {
+        fn get_counter(self: @ContractState) -> u128 {
+            self.counter.read()
+        }
+
+        fn increase_counter(ref self: ContractState, amount: u128) {
+            let current = self.counter.read();
+            self.counter.write(current + amount);
+            self.emit(CounterIncreased { amount });
+        }
+
+        fn decrease_counter(ref self: ContractState, amount: u128) {
+            let current = self.counter.read();
+            self.counter.write(current - amount);
+            self.emit(CounterDecreased { amount });
+        }
+    }
+}

basic_component/src/lib.cairo

@@ -0,0 +1,2 @@
+mod counter_contract;
+mod upgradable;

basic_component/src/upgradable.cairo

@@ -0,0 +1,41 @@
+use starknet::ClassHash;
+
+#[starknet::interface]
+trait IUpgradable<TContractState> {
+    fn upgrade(ref self: TContractState, new_class_hash: ClassHash);
+}
+
+#[starknet::component]
+mod upgradable {
+    use starknet::ClassHash;
+    use starknet::syscalls::replace_class_syscall;
+
+    #[storage]
+    struct Storage {
+        current_implementation: ClassHash
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        ContractUpgraded: ContractUpgraded
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct ContractUpgraded {
+        old_class_hash: ClassHash,
+        new_class_hash: ClassHash
+    }
+
+    #[embeddable_as(UpgradableImpl)]
+    impl Upgradable<
+        TContractState, +HasComponent<TContractState>
+    > of super::IUpgradable<ComponentState<TContractState>> {
+        fn upgrade(ref self: ComponentState<TContractState>, new_class_hash: ClassHash) {
+            replace_class_syscall(new_class_hash).unwrap();
+            let old_class_hash = self.current_implementation.read();
+            self.emit(ContractUpgraded { old_class_hash, new_class_hash });
+            self.current_implementation.write(new_class_hash);
+        }
+    }
+}

dependency1/scarb.toml

@@ -0,0 +1,10 @@
+[package]
+name = "dependency1"
+version = "0.1.0"
+
+[[target.starknet-contract]]
+allowed-libfuncs-list.name = "audited"
+casm = true
+
+[dependencies]
+starknet = ">=2.3.0-rc0"

dependency1/src/counter_contract.cairo

@@ -0,0 +1,83 @@
+use starknet::ContractAddress;
+
+#[starknet::interface]
+trait ICounterContract<TContractState> {
+    fn increase_counter(ref self: TContractState, amount: u128);
+    fn decrease_counter(ref self: TContractState, amount: u128);
+    fn get_counter(self: @TContractState) -> u128;
+}
+
+
+#[starknet::contract]
+mod counter_contract {
+    use starknet::{ContractAddress, get_caller_address};
+
+    use dependency1::upgradable::upgradable as upgradable_component;
+
+    component!(path: upgradable_component, storage: upgradable, event: UpgradableEvent);
+
+    #[abi(embed_v0)]
+    impl Upgradable = upgradable_component::UpgradableImpl<ContractState>;
+
+    impl Ownable of dependency1::upgradable::OwnableTrait<ContractState> {
+        fn is_owner(self: @ContractState, address: ContractAddress) -> bool {
+            let caller = get_caller_address();
+            let owner = self.owner_address.read();
+            caller == owner
+        }
+    }
+
+    #[storage]
+    struct Storage {
+        counter: u128,
+        owner_address: ContractAddress,
+        #[substorage(v0)]
+        upgradable: upgradable_component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        CounterIncreased: CounterIncreased,
+        CounterDecreased: CounterDecreased,
+        UpgradableEvent: upgradable_component::Event
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct CounterIncreased {
+        amount: u128
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct CounterDecreased {
+        amount: u128
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, initial_counter: u128) {
+        self.counter.write(initial_counter);
+    }
+
+    #[external(v0)]
+    impl CounterContract of super::ICounterContract<ContractState> {
+        fn get_counter(self: @ContractState) -> u128 {
+            self.counter.read()
+        }
+
+        fn increase_counter(ref self: ContractState, amount: u128) {
+            if self.is_owner(get_caller_address()) {
+                let current = self.counter.read();
+                self.counter.write(current + amount);
+                self.emit(CounterIncreased { amount });
+            }
+        }
+
+        fn decrease_counter(ref self: ContractState, amount: u128) {
+            if self.is_owner(get_caller_address()) {
+                let current = self.counter.read();
+                self.counter.write(current - amount);
+                self.emit(CounterDecreased { amount });
+            }
+        }
+    }
+}

dependency1/src/lib.cairo

@@ -0,0 +1,2 @@
+mod counter_contract;
+mod upgradable;

dependency1/src/upgradable.cairo

@@ -0,0 +1,48 @@
+use starknet::{ClassHash, ContractAddress};
+
+#[starknet::interface]
+trait IUpgradable<TContractState> {
+    fn upgrade(ref self: TContractState, new_class_hash: ClassHash);
+}
+
+trait OwnableTrait<TContractState> {
+    fn is_owner(self: @TContractState, address: ContractAddress) -> bool;
+}
+
+#[starknet::component]
+mod upgradable {
+    use starknet::{get_caller_address, ClassHash, ContractAddress};
+    use starknet::syscalls::replace_class_syscall;
+
+    #[storage]
+    struct Storage {
+        current_implementation: ClassHash
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        ContractUpgraded: ContractUpgraded
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct ContractUpgraded {
+        old_class_hash: ClassHash,
+        new_class_hash: ClassHash
+    }
+
+    #[embeddable_as(UpgradableImpl)]
+    impl Upgradable<
+        TContractState, +HasComponent<TContractState>, +super::OwnableTrait<TContractState>
+    > of super::IUpgradable<ComponentState<TContractState>> {
+        fn upgrade(ref self: ComponentState<TContractState>, new_class_hash: ClassHash) {
+            let is_owner = self.get_contract().is_owner(get_caller_address());
+            if is_owner {
+                replace_class_syscall(new_class_hash).unwrap();
+                let old_class_hash = self.current_implementation.read();
+                self.emit(ContractUpgraded { old_class_hash, new_class_hash });
+                self.current_implementation.write(new_class_hash);
+            }
+        }
+    }
+}

dependency2/scarb.toml

@@ -0,0 +1,10 @@
+[package]
+name = "dependency2"
+version = "0.1.0"
+
+[[target.starknet-contract]]
+allowed-libfuncs-list.name = "audited"
+casm = true
+
+[dependencies]
+starknet = ">=2.3.0-rc0"