diff --git a/flex_marketplace/src/marketplace/strategy_standard_sale_for_fixed_price.cairo b/flex_marketplace/src/marketplace/strategy_standard_sale_for_fixed_price.cairo
index 6bda63c..e63e13b 100644
--- a/flex_marketplace/src/marketplace/strategy_standard_sale_for_fixed_price.cairo
+++ b/flex_marketplace/src/marketplace/strategy_standard_sale_for_fixed_price.cairo
@@ -1,15 +1,11 @@
 use starknet::ContractAddress;
-
+use starknet::class_hash::ClassHash;
 use flex::marketplace::utils::order_types::{TakerOrder, MakerOrder};
 
 #[starknet::interface]
 trait IStrategyStandardSaleForFixedPrice<TState> {
-    fn initializer(
-        ref self: TState, fee: u128, owner: ContractAddress, proxy_admin: ContractAddress
-    );
+    fn initializer(ref self: TState, fee: u128, owner: ContractAddress);
     fn update_protocol_fee(ref self: TState, fee: u128);
-    fn transfer_ownership(ref self: TState, new_owner: ContractAddress);
-    fn owner(self: @TState) -> ContractAddress;
     fn protocol_fee(self: @TState) -> u128;
     fn can_execute_taker_ask(
         self: @TState, taker_ask: TakerOrder, maker_bid: MakerOrder, extra_params: Span<felt252>
@@ -17,14 +13,19 @@ trait IStrategyStandardSaleForFixedPrice<TState> {
     fn can_execute_taker_bid(
         self: @TState, taker_bid: TakerOrder, maker_ask: MakerOrder
     ) -> (bool, u256, u128);
+    fn upgrade(ref self: TState, impl_hash: ClassHash);
 }
 
 #[starknet::contract]
 mod StrategyStandardSaleForFixedPrice {
     use starknet::{ContractAddress, contract_address_const};
-
+    use starknet::class_hash::ClassHash;
+    use starknet::get_block_timestamp;
+    use openzeppelin::upgrades::upgradeable::UpgradeableComponent::InternalTrait;
+    use openzeppelin::upgrades::UpgradeableComponent;
     use openzeppelin::access::ownable::OwnableComponent;
     component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(path: UpgradeableComponent, storage: upgradable, event: UpgradeableEvent);
 
     #[abi(embed_v0)]
     impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
@@ -37,38 +38,36 @@ mod StrategyStandardSaleForFixedPrice {
     struct Storage {
         protocol_fee: u128,
         #[substorage(v0)]
-        ownable: OwnableComponent::Storage
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        upgradable: UpgradeableComponent::Storage,
     }
 
     #[event]
     #[derive(Drop, starknet::Event)]
     enum Event {
+        #[flat]
         OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        UpgradeableEvent: UpgradeableComponent::Event,
     }
 
     #[external(v0)]
     impl StrategyStandardSaleForFixedPriceImpl of super::IStrategyStandardSaleForFixedPrice<
         ContractState
     > {
-        fn initializer(
-            ref self: ContractState, fee: u128, owner: ContractAddress, proxy_admin: ContractAddress
-        ) { // TODO
-        }
-
-        fn update_protocol_fee(ref self: ContractState, fee: u128) { // TODO
+        fn initializer(ref self: ContractState, fee: u128, owner: ContractAddress) {
+            self.ownable.initializer(owner);
+            self.protocol_fee.write(fee);
         }
 
-        fn transfer_ownership(ref self: ContractState, new_owner: ContractAddress) { // TODO
-        }
-
-        fn owner(self: @ContractState) -> ContractAddress {
-            // TODO
-            contract_address_const::<0>()
+        fn update_protocol_fee(ref self: ContractState, fee: u128) {
+            self.ownable.assert_only_owner();
+            self.protocol_fee.write(fee);
         }
 
         fn protocol_fee(self: @ContractState) -> u128 {
-            // TODO
-            0
+            self.protocol_fee.read()
         }
 
         fn can_execute_taker_ask(
@@ -77,14 +76,33 @@ mod StrategyStandardSaleForFixedPrice {
             maker_bid: MakerOrder,
             extra_params: Span<felt252>
         ) -> (bool, u256, u128) {
-            // TODO
-            (true, 0, 0)
+            let price_match: bool = maker_bid.price == taker_ask.price;
+            let token_id_match: bool = maker_bid.token_id == taker_ask.token_id;
+            let start_time_valid: bool = maker_bid.start_time < get_block_timestamp();
+            let end_time_valid: bool = maker_bid.end_time > get_block_timestamp();
+            if (price_match && token_id_match && start_time_valid && end_time_valid) {
+                return (true, maker_bid.token_id, maker_bid.amount);
+            } else {
+                return (false, maker_bid.token_id, maker_bid.amount);
+            }
         }
         fn can_execute_taker_bid(
             self: @ContractState, taker_bid: TakerOrder, maker_ask: MakerOrder
         ) -> (bool, u256, u128) {
-            // TODO
-            (true, 0, 0)
+            let price_match: bool = maker_ask.price == taker_bid.price;
+            let token_id_match: bool = maker_ask.token_id == taker_bid.token_id;
+            let start_time_valid: bool = maker_ask.start_time < get_block_timestamp();
+            let end_time_valid: bool = maker_ask.end_time > get_block_timestamp();
+            if (price_match && token_id_match && start_time_valid && end_time_valid) {
+                return (true, maker_ask.token_id, maker_ask.amount);
+            } else {
+                return (false, maker_ask.token_id, maker_ask.amount);
+            }
+        }
+
+        fn upgrade(ref self: ContractState, impl_hash: ClassHash) {
+            self.ownable.assert_only_owner();
+            self.upgradable._upgrade(impl_hash);
         }
     }
 }
diff --git a/flex_marketplace/src/marketplace/utils/order_types.cairo b/flex_marketplace/src/marketplace/utils/order_types.cairo
index 2afc76f..1995baf 100644
--- a/flex_marketplace/src/marketplace/utils/order_types.cairo
+++ b/flex_marketplace/src/marketplace/utils/order_types.cairo
@@ -1,7 +1,28 @@
-#[derive(Drop, Serde)]
-struct MakerOrder { // TODO
+use starknet::ContractAddress;
+
+#[derive(Copy, Drop, Serde)]
+struct MakerOrder {
+    is_order_ask: bool, // 1 = ask / 0 = bid
+    signer: ContractAddress, // signer of the maker order
+    collection: ContractAddress, // collection address
+    price: u128,
+    token_id: u256,
+    amount: u128, // amount of tokens to sell/purchase (must be 1 for ERC721, 1+ for ERC1155)
+    strategy: ContractAddress, // strategy address for trade execution (e.g. StandardSaleForFixedPrice)
+    currency: ContractAddress, // currency address
+    nonce: u128, // order nonce (must be unique unless new maker order is meant to override existing one e.g. lower ask price)
+    start_time: u64, // startTime in timestamp
+    end_time: u64, // endTime in timestamp
+    min_percentage_to_ask: u128, // slippage protection (9000 = 90% of the final price must return to ask)
+    params: felt252,
 }
 
-#[derive(Drop, Serde)]
-struct TakerOrder { // TODO
+#[derive(Copy, Drop, Serde)]
+struct TakerOrder {
+    is_order_ask: bool, // 1 = ask / 0 = bid
+    taker: ContractAddress, // caller
+    price: u128, // final price for the purchase
+    token_id: u256,
+    min_percentage_to_ask: u128, // slippage protection (9000 = 90% of the final price must return to ask)
+    params: felt252,
 }