feat: Use indexes for LogData

book/src/smart-contracts-architecture/utils-module.md

@@ -32,6 +32,8 @@ It contains the following files:
 
 - [precision.cairo](https://github.com/keep-starknet-strange/satoru/blob/main/src/utils/precision.cairo): This offers utility functions for detailed math and changing units, helping with accurate calculations and conversions between different measures, like from float to wei, applying factors, and managing rounding in the Satoru Starknet smart contract environment.
 
+- [serializable_dict.cairo](https://github.com/keep-starknet-strange/satoru/blob/main/src/utils/serializable_dict.cairo): This file defines the SerializableFelt252Dict structure that allows us to use a Felt252Dict and serialize/deserialize it. 
+
 - [span32.cairo](https://github.com/keep-starknet-strange/satoru/blob/main/src/utils/span32.cairo): Provides utility functions for managing and manipulating fixed-size arrays (span32). A wrapper around Span type with a maximum size of 32. Used to prevent size overflow when storing Span.
 
 - [starknet_utils.cairo](https://github.com/keep-starknet-strange/satoru/blob/main/src/utils/starknet_utils.cairo): This puts in place fake utilities to mimic Starknet environment features, like `gasleft` and `tx.gasprice`, in the Satoru Starknet smart contract environment. These functions give back set values based on the given parameters, allowing a way to mimic Starknet gas actions during testing and development.

src/callback/callback_utils.cairo

@@ -23,7 +23,7 @@ use starknet::ContractAddress;
 // Local imports.
 use satoru::data::data_store::{IDataStoreDispatcher, IDataStoreDispatcherTrait};
 use satoru::data::keys;
-use satoru::event::event_utils::LogData;
+use satoru::event::event_utils::{LogData, LogDataTrait};
 use satoru::order::order::Order;
 use satoru::deposit::deposit::Deposit;
 use satoru::withdrawal::withdrawal::Withdrawal;
@@ -92,98 +92,98 @@ fn get_saved_callback_contract(
 /// * `key` - They key of the deposit.
 /// * `deposit` - The deposit that was executed.
 /// * `log_data` - The log data.
-fn after_deposit_execution(key: felt252, deposit: Deposit, log_data: LogData) {
+fn after_deposit_execution(key: felt252, deposit: Deposit, mut log_data: LogData) {
     if !is_valid_callback_contract(deposit.callback_contract) {
         return;
     }
     let dispatcher = IDepositCallbackReceiverDispatcher {
         contract_address: deposit.callback_contract
     };
-    dispatcher.after_deposit_execution(key, deposit, log_data)
+    dispatcher.after_deposit_execution(key, deposit, log_data.serialize_into())
 }
 
 /// Called after a deposit cancellation.
 /// # Arguments
 /// * `key` - They key of the deposit.
 /// * `deposit` - The deposit that was cancelled.
 /// * `log_data` - The log data.
-fn after_deposit_cancellation(key: felt252, deposit: Deposit, log_data: LogData) {
+fn after_deposit_cancellation(key: felt252, deposit: Deposit, mut log_data: LogData) {
     if !is_valid_callback_contract(deposit.callback_contract) {
         return;
     }
     let dispatcher = IDepositCallbackReceiverDispatcher {
         contract_address: deposit.callback_contract
     };
-    dispatcher.after_deposit_cancellation(key, deposit, log_data)
+    dispatcher.after_deposit_cancellation(key, deposit, log_data.serialize_into())
 }
 
 /// Called after a withdrawal execution.
 /// # Arguments
 /// * `key` - They key of the withdrawal.
 /// * `withdrawal` - The withdrawal that was executed.
 /// * `log_data` - The log data.
-fn after_withdrawal_execution(key: felt252, withdrawal: Withdrawal, log_data: LogData) {
+fn after_withdrawal_execution(key: felt252, withdrawal: Withdrawal, mut log_data: LogData) {
     if !is_valid_callback_contract(withdrawal.callback_contract) {
         return;
     }
     let dispatcher = IWithdrawalCallbackReceiverDispatcher {
         contract_address: withdrawal.callback_contract
     };
-    dispatcher.after_withdrawal_execution(key, withdrawal, log_data)
+    dispatcher.after_withdrawal_execution(key, withdrawal, log_data.serialize_into())
 }
 
 /// Called after an withdrawal cancellation.
 /// # Arguments
 /// * `key` - They key of the withdrawal.
 /// * `withdrawal` - The withdrawal that was cancelled.
 /// * `log_data` - The log data.
-fn after_withdrawal_cancellation(key: felt252, withdrawal: Withdrawal, log_data: LogData) {
+fn after_withdrawal_cancellation(key: felt252, withdrawal: Withdrawal, mut log_data: LogData) {
     if !is_valid_callback_contract(withdrawal.callback_contract) {
         return;
     }
     let dispatcher = IWithdrawalCallbackReceiverDispatcher {
         contract_address: withdrawal.callback_contract
     };
-    dispatcher.after_withdrawal_cancellation(key, withdrawal, log_data)
+    dispatcher.after_withdrawal_cancellation(key, withdrawal, log_data.serialize_into())
 }
 
 /// Called after an order execution.
 /// # Arguments
 /// * `key` - They key of the order.
 /// * `order` - The order that was executed.
 /// * `log_data` - The log data.
-fn after_order_execution(key: felt252, order: Order, log_data: LogData) {
+fn after_order_execution(key: felt252, order: Order, mut log_data: LogData) {
     if !is_valid_callback_contract(order.callback_contract) {
         return;
     }
     let dispatcher = IOrderCallbackReceiverDispatcher { contract_address: order.callback_contract };
-    dispatcher.after_order_execution(key, order, log_data)
+    dispatcher.after_order_execution(key, order, log_data.serialize_into())
 }
 
 /// Called after an order cancellation.
 /// # Arguments
 /// * `key` - They key of the order.
 /// * `order` - The order that was cancelled.
 /// * `log_data` - The log data.
-fn after_order_cancellation(key: felt252, order: Order, log_data: LogData) {
+fn after_order_cancellation(key: felt252, order: Order, mut log_data: LogData) {
     if !is_valid_callback_contract(order.callback_contract) {
         return;
     }
     let dispatcher = IOrderCallbackReceiverDispatcher { contract_address: order.callback_contract };
-    dispatcher.after_order_cancellation(key, order, log_data)
+    dispatcher.after_order_cancellation(key, order, log_data.serialize_into())
 }
 
 /// Called after an order cancellation.
 /// # Arguments
 /// * `key` - They key of the order.
 /// * `order` - The order that was frozen.
 /// * `log_data` - The log data.
-fn after_order_frozen(key: felt252, order: Order, log_data: LogData) {
+fn after_order_frozen(key: felt252, order: Order, mut log_data: LogData) {
     if !is_valid_callback_contract(order.callback_contract) {
         return;
     }
     let dispatcher = IOrderCallbackReceiverDispatcher { contract_address: order.callback_contract };
-    dispatcher.after_order_frozen(key, order, log_data)
+    dispatcher.after_order_frozen(key, order, log_data.serialize_into())
 }
 
 /// Validates that the given address is a contract.

src/callback/deposit_callback_receiver/interface.cairo

@@ -13,7 +13,7 @@ trait IDepositCallbackReceiver<TContractState> {
     /// * `event_data` - The event log data.
     /// * `deposit` - The deposit that was executed.
     fn after_deposit_execution(
-        ref self: TContractState, key: felt252, deposit: Deposit, log_data: LogData,
+        ref self: TContractState, key: felt252, deposit: Deposit, log_data: Array<felt252>,
     );
 
     /// Called after a deposit cancellation.
@@ -22,6 +22,6 @@ trait IDepositCallbackReceiver<TContractState> {
     /// * `event_data` - The event log data.
     /// * `deposit` - The deposit that was cancelled.
     fn after_deposit_cancellation(
-        ref self: TContractState, key: felt252, deposit: Deposit, log_data: LogData,
+        ref self: TContractState, key: felt252, deposit: Deposit, log_data: Array<felt252>,
     );
 }

src/callback/mocks.cairo

@@ -35,13 +35,13 @@ mod CallbackMock {
     #[external(v0)]
     impl IDepositCallbackReceiverImpl of IDepositCallbackReceiver<ContractState> {
         fn after_deposit_execution(
-            ref self: ContractState, key: felt252, deposit: Deposit, log_data: LogData,
+            ref self: ContractState, key: felt252, deposit: Deposit, log_data: Array<felt252>,
         ) {
             self.counter.write(self.get_counter() + 1);
         }
 
         fn after_deposit_cancellation(
-            ref self: ContractState, key: felt252, deposit: Deposit, log_data: LogData,
+            ref self: ContractState, key: felt252, deposit: Deposit, log_data: Array<felt252>,
         ) {
             self.counter.write(self.get_counter() + 1);
         }

src/callback/order_callback_receiver/interface.cairo

@@ -13,7 +13,7 @@ trait IOrderCallbackReceiver<TContractState> {
     /// * `order` - The order that was executed.
     /// * `log_data` - The log data.
     fn after_order_execution(
-        ref self: TContractState, key: felt252, order: Order, log_data: LogData
+        ref self: TContractState, key: felt252, order: Order, log_data: Array<felt252>
     );
 
     /// Called after an order cancellation.
@@ -22,13 +22,15 @@ trait IOrderCallbackReceiver<TContractState> {
     /// * `order` - The order that was cancelled.
     /// * `log_data` - The log data.
     fn after_order_cancellation(
-        ref self: TContractState, key: felt252, order: Order, log_data: LogData
+        ref self: TContractState, key: felt252, order: Order, log_data: Array<felt252>
     );
 
     /// Called after an order cancellation.
     /// # Arguments
     /// * `key` - They key of the order.
     /// * `order` - The order that was frozen.
     /// * `log_data` - The log data.
-    fn after_order_frozen(ref self: TContractState, key: felt252, order: Order, log_data: LogData);
+    fn after_order_frozen(
+        ref self: TContractState, key: felt252, order: Order, log_data: Array<felt252>
+    );
 }

src/callback/withdrawal_callback_receiver/interface.cairo

@@ -14,7 +14,7 @@ trait IWithdrawalCallbackReceiver<TContractState> {
     /// * `log_data` - The log data.
     // TODO uncomment withdrawal when available
     fn after_withdrawal_execution(
-        ref self: TContractState, key: felt252, withdrawal: Withdrawal, log_data: LogData,
+        ref self: TContractState, key: felt252, withdrawal: Withdrawal, log_data: Array<felt252>,
     );
 
     /// Called after an withdrawal cancellation.
@@ -23,6 +23,6 @@ trait IWithdrawalCallbackReceiver<TContractState> {
     /// * `withdrawal` - The withdrawal that was cancelled.
     /// * `log_data` - The log data.
     fn after_withdrawal_cancellation(
-        ref self: TContractState, key: felt252, withdrawal: Withdrawal, log_data: LogData,
+        ref self: TContractState, key: felt252, withdrawal: Withdrawal, log_data: Array<felt252>,
     );
 }

src/deposit/deposit_utils.cairo

@@ -184,7 +184,7 @@ fn cancel_deposit(
 
     event_emitter.emit_deposit_cancelled(key, reason, reason_bytes.span());
 
-    let log_data: LogData = Default::default();
+    let mut log_data: LogData = Default::default();
     after_deposit_cancellation(key, deposit, log_data);
 
     gas_utils::pay_execution_fee_deposit(

src/deposit/execute_deposit_utils.cairo

@@ -20,7 +20,10 @@ use satoru::deposit::{
     deposit_vault::{IDepositVaultDispatcher, IDepositVaultDispatcherTrait}, error::DepositError
 };
 use satoru::event::event_emitter::{IEventEmitterDispatcher, IEventEmitterDispatcherTrait};
-use satoru::event::event_utils::{LogData, set_item_uint_items, UintItems};
+use satoru::event::event_utils::{
+    LogData, LogDataTrait, Felt252IntoU128, ContractAddressDictValue, I128252DictValue
+};
+use satoru::utils::serializable_dict::{SerializableFelt252Dict, SerializableFelt252DictTrait};
 use satoru::fee::fee_utils;
 use satoru::gas::gas_utils::pay_execution_fee_deposit;
 use satoru::market::{
@@ -237,9 +240,8 @@ fn execute_deposit(params: ExecuteDepositParams) {
             cache.received_market_tokens,
         );
 
-    let event_data: LogData = Default::default();
-    let mut uint_items: UintItems = Default::default();
-    set_item_uint_items(uint_items, 0, 'received_market_tokens', cache.received_market_tokens);
+    let mut event_data: LogData = Default::default();
+    event_data.uint_dict.insert_single('received_market_tokens', cache.received_market_tokens);
     after_deposit_execution(params.key, deposit, event_data);
 
     pay_execution_fee_deposit(