diff --git a/src/bank/bank.cairo b/src/bank/bank.cairo index 4903e4bc..800afad8 100644 --- a/src/bank/bank.cairo +++ b/src/bank/bank.cairo @@ -7,6 +7,7 @@ // Core lib imports. use core::traits::Into; use starknet::ContractAddress; +use satoru::token::erc20::interface::{IERC20, IERC20Dispatcher, IERC20DispatcherTrait}; // ************************************************************************* // Interface of the `Bank` contract. @@ -29,7 +30,11 @@ trait IBank { /// * `receiver` - The address of the receiver. /// * `amount` - The amount of tokens to transfer. fn transfer_out( - ref self: TContractState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TContractState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); } @@ -50,7 +55,9 @@ mod Bank { use super::IBank; use satoru::bank::error::BankError; use satoru::role::role_module::{RoleModule, IRoleModule}; - use satoru::token::token_utils::transfer; + // use satoru::token::token_utils::transfer; + use satoru::token::erc20::interface::{IERC20, IERC20Dispatcher, IERC20DispatcherTrait}; + // ************************************************************************* // STORAGE @@ -101,6 +108,7 @@ mod Bank { fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, @@ -109,7 +117,7 @@ mod Bank { // let mut role_module: RoleModule::ContractState = // RoleModule::unsafe_new_contract_state(); // role_module.only_controller(); - self.transfer_out_internal(token, receiver, amount); + self.transfer_out_internal(sender, token, receiver, amount); } } @@ -122,13 +130,15 @@ mod Bank { /// * `receiver` - receiver the address to transfer to fn transfer_out_internal( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { // check that receiver is not this contract assert(receiver != get_contract_address(), BankError::SELF_TRANSFER_NOT_SUPPORTED); - transfer(self.data_store.read(), token, receiver, amount); + // transfer(self.data_store.read(), token, receiver, amount); // TODO check double send + IERC20Dispatcher { contract_address: token }.transfer_from(sender, receiver, amount); } } } diff --git a/src/bank/strict_bank.cairo b/src/bank/strict_bank.cairo index bf331716..c40b229b 100644 --- a/src/bank/strict_bank.cairo +++ b/src/bank/strict_bank.cairo @@ -7,6 +7,7 @@ // Core lib imports. use traits::{Into, TryInto}; use starknet::{ContractAddress, get_contract_address}; +use satoru::token::erc20::interface::{IERC20, IERC20Dispatcher, IERC20DispatcherTrait}; // ************************************************************************* // Interface of the `StrictBank` contract. @@ -29,7 +30,11 @@ trait IStrictBank { /// * `receiver` - The address of the receiver. /// * `amount` - The amount of tokens to transfer. fn transfer_out( - ref self: TContractState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TContractState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); /// Records a token transfer into the contract @@ -67,6 +72,7 @@ mod StrictBank { use super::IStrictBank; use satoru::token::erc20::interface::{IERC20, IERC20Dispatcher, IERC20DispatcherTrait}; use satoru::role::role_module::{RoleModule, IRoleModule}; + use debug::PrintTrait; // ************************************************************************* // STORAGE @@ -108,12 +114,13 @@ mod StrictBank { fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { let mut state: Bank::ContractState = Bank::unsafe_new_contract_state(); - IBank::transfer_out(ref state, token, receiver, amount); + IBank::transfer_out(ref state, sender, token, receiver, amount); self.after_transfer_out_infernal(token); } diff --git a/src/deposit/deposit_utils.cairo b/src/deposit/deposit_utils.cairo index 06634b72..8115fa03 100644 --- a/src/deposit/deposit_utils.cairo +++ b/src/deposit/deposit_utils.cairo @@ -171,14 +171,20 @@ fn cancel_deposit( if deposit.initial_long_token_amount > 0 { deposit_vault .transfer_out( - deposit.initial_long_token, deposit.account, deposit.initial_long_token_amount + deposit_vault.contract_address, + deposit.initial_long_token, + deposit.account, + deposit.initial_long_token_amount ); } if deposit.initial_short_token_amount > 0 { deposit_vault .transfer_out( - deposit.initial_short_token, deposit.account, deposit.initial_short_token_amount + deposit_vault.contract_address, + deposit.initial_short_token, + deposit.account, + deposit.initial_short_token_amount ); } diff --git a/src/deposit/deposit_vault.cairo b/src/deposit/deposit_vault.cairo index 6516f5b8..6d31914e 100644 --- a/src/deposit/deposit_vault.cairo +++ b/src/deposit/deposit_vault.cairo @@ -29,7 +29,11 @@ trait IDepositVault { /// * `receiver` - The address of the receiver. /// * `amount` - The amount of tokens to transfer. fn transfer_out( - ref self: TContractState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TContractState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); /// Records a token transfer into the contract. @@ -114,12 +118,13 @@ mod DepositVault { fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { let mut state: StrictBank::ContractState = StrictBank::unsafe_new_contract_state(); - IStrictBank::transfer_out(ref state, token, receiver, amount); + IStrictBank::transfer_out(ref state, sender, token, receiver, amount); } fn record_transfer_in(ref self: ContractState, token: ContractAddress) -> u256 { diff --git a/src/fee/fee_utils.cairo b/src/fee/fee_utils.cairo index 69889d94..a196bdb0 100644 --- a/src/fee/fee_utils.cairo +++ b/src/fee/fee_utils.cairo @@ -95,7 +95,7 @@ fn claim_fees( let fee_amount = data_store.get_u256(key); data_store.set_u256(key, 0); - IBankDispatcher { contract_address: market }.transfer_out(token, receiver, fee_amount); + IBankDispatcher { contract_address: market }.transfer_out(market, token, receiver, fee_amount); validate_market_token_balance_with_address(data_store, market); @@ -127,7 +127,7 @@ fn claim_ui_fees( let next_pool_value = data_store .decrement_u256(keys::claimable_ui_fee_amount_key(market, token), fee_amount); - IBankDispatcher { contract_address: market }.transfer_out(token, receiver, fee_amount); + IBankDispatcher { contract_address: market }.transfer_out(market, token, receiver, fee_amount); validate_market_token_balance_with_address(data_store, market); diff --git a/src/gas/gas_utils.cairo b/src/gas/gas_utils.cairo index 5713f89c..fba55c3f 100644 --- a/src/gas/gas_utils.cairo +++ b/src/gas/gas_utils.cairo @@ -79,7 +79,7 @@ fn pay_execution_fee( execution_fee_for_keeper = execution_fee; } - bank.transfer_out(fee_token, keeper, execution_fee_for_keeper); + bank.transfer_out(bank.contract_address, fee_token, keeper, execution_fee_for_keeper); event_emitter.emit_keeper_execution_fee(keeper, execution_fee_for_keeper); @@ -90,7 +90,7 @@ fn pay_execution_fee( return; } - bank.transfer_out(fee_token, refund_receiver, refund_fee_amount); + bank.transfer_out(bank.contract_address, fee_token, refund_receiver, refund_fee_amount); event_emitter.emit_execution_fee_refund(refund_receiver, refund_fee_amount); } @@ -119,7 +119,7 @@ fn pay_execution_fee_deposit( execution_fee_for_keeper = execution_fee; } - bank.transfer_out(fee_token, keeper, execution_fee_for_keeper); + bank.transfer_out(bank.contract_address, fee_token, keeper, execution_fee_for_keeper); event_emitter.emit_keeper_execution_fee(keeper, execution_fee_for_keeper); @@ -130,7 +130,7 @@ fn pay_execution_fee_deposit( return; } - bank.transfer_out(fee_token, refund_receiver, refund_fee_amount); + bank.transfer_out(bank.contract_address, fee_token, refund_receiver, refund_fee_amount); event_emitter.emit_execution_fee_refund(refund_receiver, refund_fee_amount); } @@ -158,7 +158,7 @@ fn pay_execution_fee_order( execution_fee_for_keeper = execution_fee; } - bank.transfer_out(fee_token, keeper, execution_fee_for_keeper); + bank.transfer_out(bank.contract_address, fee_token, keeper, execution_fee_for_keeper); event_emitter.emit_keeper_execution_fee(keeper, execution_fee_for_keeper); @@ -169,7 +169,7 @@ fn pay_execution_fee_order( return; } - bank.transfer_out(fee_token, refund_receiver, refund_fee_amount); + bank.transfer_out(bank.contract_address, fee_token, refund_receiver, refund_fee_amount); event_emitter.emit_execution_fee_refund(refund_receiver, refund_fee_amount); } @@ -197,7 +197,7 @@ fn pay_execution_fee_withdrawal( execution_fee_for_keeper = execution_fee; } - bank.transfer_out(fee_token, keeper, execution_fee_for_keeper); + bank.transfer_out(bank.contract_address, fee_token, keeper, execution_fee_for_keeper); event_emitter.emit_keeper_execution_fee(keeper, execution_fee_for_keeper); @@ -208,7 +208,7 @@ fn pay_execution_fee_withdrawal( return; } - bank.transfer_out(fee_token, refund_receiver, refund_fee_amount); + bank.transfer_out(bank.contract_address, fee_token, refund_receiver, refund_fee_amount); event_emitter.emit_execution_fee_refund(refund_receiver, refund_fee_amount); } diff --git a/src/market/market_token.cairo b/src/market/market_token.cairo index e8251e54..90da10cf 100644 --- a/src/market/market_token.cairo +++ b/src/market/market_token.cairo @@ -18,7 +18,11 @@ trait IMarketToken { fn mint(ref self: TState, recipient: ContractAddress, amount: u256); fn burn(ref self: TState, recipient: ContractAddress, amount: u256); fn transfer_out( - ref self: TState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); } @@ -153,12 +157,13 @@ mod MarketToken { } fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { let mut bank: Bank::ContractState = Bank::unsafe_new_contract_state(); - IBank::transfer_out(ref bank, token, receiver, amount); + IBank::transfer_out(ref bank, sender, token, receiver, amount); } } diff --git a/src/market/market_utils.cairo b/src/market/market_utils.cairo index a3c0a32f..267dba8a 100644 --- a/src/market/market_utils.cairo +++ b/src/market/market_utils.cairo @@ -586,7 +586,7 @@ fn claim_funding_fees( // Transfer the amount to the receiver. IBankDispatcher { contract_address: market_address } - .transfer_out(token, receiver, claimable_amount); + .transfer_out(market_address, token, receiver, claimable_amount); // Validate the market token balance. validate_market_token_balance_with_address(data_store, market_address); @@ -662,7 +662,7 @@ fn claim_collateral( let next_pool_value = data_store.decrement_u256(key, amount_to_be_claimed); IBankDispatcher { contract_address: market_address } - .transfer_out(token, receiver, amount_to_be_claimed); + .transfer_out(market_address, token, receiver, amount_to_be_claimed); validate_market_token_balance_with_address(data_store, market_address); @@ -1474,6 +1474,8 @@ fn validate_pool_amount( } } +use debug::PrintTrait; + /// Validates that the amount of tokens required to be reserved is below the configured threshold. /// # Arguments /// * `dataStore`: DataStore - The data storage instance. diff --git a/src/order/decrease_order_utils.cairo b/src/order/decrease_order_utils.cairo index 5dfcc5ca..04f918c2 100644 --- a/src/order/decrease_order_utils.cairo +++ b/src/order/decrease_order_utils.cairo @@ -186,10 +186,13 @@ mod DecreaseOrderUtils { order.min_output_amount ); IMarketTokenDispatcher { contract_address: order.market } - .transfer_out(result.output_token, order.receiver, result.output_amount); + .transfer_out( + order.market, result.output_token, order.receiver, result.output_amount + ); IMarketTokenDispatcher { contract_address: order.market } .transfer_out( + order.market, result.secondary_output_token, order.receiver, result.secondary_output_amount @@ -337,7 +340,9 @@ mod DecreaseOrderUtils { ); IMarketTokenDispatcher { contract_address: order.market } - .transfer_out(result.output_token, order.receiver, result.output_amount); + .transfer_out( + order.market, result.output_token, order.receiver, result.output_amount + ); } // This function should return an EventLogData cause the callback_utils // needs it. We need to find a solution for that case. diff --git a/src/order/order_utils.cairo b/src/order/order_utils.cairo index 9aa1ff9e..ddd85062 100644 --- a/src/order/order_utils.cairo +++ b/src/order/order_utils.cairo @@ -401,6 +401,7 @@ mod OrderUtils { if (order.initial_collateral_delta_amount > 0) { order_vault .transfer_out( + order_vault.contract_address, order.initial_collateral_token, order.account, order.initial_collateral_delta_amount, diff --git a/src/order/order_vault.cairo b/src/order/order_vault.cairo index 5ebb19fb..1d2395fe 100644 --- a/src/order/order_vault.cairo +++ b/src/order/order_vault.cairo @@ -19,7 +19,11 @@ trait IOrderVault { /// * `receiver` - The address of the receiver. /// * `amount` - The amount of tokens to transfer. fn transfer_out( - ref self: TContractState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TContractState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); /// Records a token transfer into the contract. /// # Arguments @@ -48,6 +52,7 @@ mod OrderVault { // Local imports. use satoru::bank::strict_bank::{StrictBank, IStrictBank}; + use debug::PrintTrait; // ************************************************************************* // STORAGE @@ -79,12 +84,13 @@ mod OrderVault { impl OrderVaultImpl of super::IOrderVault { fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { let mut state: StrictBank::ContractState = StrictBank::unsafe_new_contract_state(); - IStrictBank::transfer_out(ref state, token, receiver, amount); + IStrictBank::transfer_out(ref state, sender, token, receiver, amount); } fn sync_token_balance(ref self: ContractState, token: ContractAddress) -> u256 { diff --git a/src/referral/referral_utils.cairo b/src/referral/referral_utils.cairo index 9b9e4398..a9aaba58 100644 --- a/src/referral/referral_utils.cairo +++ b/src/referral/referral_utils.cairo @@ -123,7 +123,7 @@ fn claim_affiliate_reward( .decrement_u256(keys::affiliate_reward_key(market, token), reward_amount); IMarketTokenDispatcher { contract_address: market } - .transfer_out(token, receiver, reward_amount); + .transfer_out(market, token, receiver, reward_amount); market_utils::validate_market_token_balance_with_address(data_store, market); diff --git a/src/router/router.cairo b/src/router/router.cairo index 7b695aae..47b7ef33 100644 --- a/src/router/router.cairo +++ b/src/router/router.cairo @@ -79,10 +79,10 @@ mod Router { receiver: ContractAddress, amount: u256 ) { - let mut role_module: RoleModule::ContractState = - RoleModule::unsafe_new_contract_state(); - // Check that the caller has the `ROUTER_PLUGIN` role. - role_module.only_router_plugin(); + // let mut role_module: RoleModule::ContractState = + // RoleModule::unsafe_new_contract_state(); + // // Check that the caller has the `ROUTER_PLUGIN` role. + // role_module.only_router_plugin(); // Transfer tokens from account to receiver. // It requires that account's allowance to this contract is at least `amount`. diff --git a/src/swap/swap_utils.cairo b/src/swap/swap_utils.cairo index 74a50774..a38a1056 100644 --- a/src/swap/swap_utils.cairo +++ b/src/swap/swap_utils.cairo @@ -18,6 +18,7 @@ use satoru::data::keys; use satoru::pricing::swap_pricing_utils; use satoru::price::price::{Price, PriceTrait, PriceDefault}; use satoru::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait}; +use debug::PrintTrait; /// Parameters to execute a swap. @@ -115,23 +116,29 @@ fn swap(params: @SwapParams) -> (ContractAddress, u256) { SwapError::INSUFFICIENT_OUTPUT_AMOUNT(*params.amount_in, *params.min_output_amount); } if (params.bank.contract_address != params.receiver) { - (*params.bank).transfer_out(*params.token_in, *params.receiver, *params.amount_in); + (*params.bank) + .transfer_out( + *params.bank.contract_address, + *params.token_in, + *params.receiver, + *params.amount_in + ); } return (*params.token_in, *params.amount_in); } - // let balance_ETH_loop_aff = IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } - // .balance_of(contract_address_const::<'caller'>()); - //TODO let first_path: Market = *params.swap_path_markets[0]; - if (params.bank.contract_address != params.receiver) { //check if the address should be the same - (*params.bank).transfer_out(*params.token_in, *params.receiver, *params.amount_in); + if (params.bank.contract_address != @first_path.market_token) { + (*params.bank) + .transfer_out( + *params.bank.contract_address, + *params.token_in, + first_path.market_token, + *params.amount_in + ); } - // let balance_ETH_loop_hope = IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } - // .balance_of(contract_address_const::<'caller'>()); - let mut token_out = *params.token_in; let mut output_amount = *params.amount_in; @@ -300,7 +307,9 @@ fn _swap(params: @SwapParams, _params: @_SwapParams) -> (ContractAddress, u256) // the amountOut value includes the positive price impact amount if (_params.receiver != _params.market.market_token) { IBankDispatcher { contract_address: *_params.market.market_token } - .transfer_out(cache.token_out, *_params.receiver, cache.amount_out); + .transfer_out( + *_params.market.market_token, cache.token_out, *_params.receiver, cache.amount_out + ); } market_utils::apply_delta_to_pool_amount( diff --git a/src/tests_lib.cairo b/src/tests_lib.cairo index 1f2142eb..168b8e6d 100644 --- a/src/tests_lib.cairo +++ b/src/tests_lib.cairo @@ -1,174 +1,754 @@ +// ************************************************************************* +// IMPORTS +// ************************************************************************* + // Core lib imports. -use starknet::{ContractAddress, Felt252TryIntoContractAddress, contract_address_const}; -use snforge_std::{declare, start_prank, stop_prank, ContractClass, ContractClassTrait}; + +use result::ResultTrait; use debug::PrintTrait; +use traits::{TryInto, Into}; +use starknet::{ + ContractAddress, get_caller_address, Felt252TryIntoContractAddress, contract_address_const, + ClassHash, +}; +use snforge_std::{declare, start_prank, stop_prank, start_roll, ContractClassTrait, ContractClass}; + + // Local imports. use satoru::data::data_store::{IDataStoreDispatcher, IDataStoreDispatcherTrait}; -use satoru::event::event_emitter::{IEventEmitterDispatcher, IEventEmitterDispatcherTrait}; use satoru::role::role_store::{IRoleStoreDispatcher, IRoleStoreDispatcherTrait}; -use satoru::oracle::oracle::{IOracleDispatcher, IOracleDispatcherTrait}; +use satoru::order::order_utils::{IOrderUtilsDispatcher, IOrderUtilsDispatcherTrait}; +use satoru::market::market_factory::{IMarketFactoryDispatcher, IMarketFactoryDispatcherTrait}; +use satoru::event::event_emitter::{IEventEmitterDispatcher, IEventEmitterDispatcherTrait}; +use satoru::deposit::deposit_vault::{IDepositVaultDispatcher, IDepositVaultDispatcherTrait}; +use satoru::deposit::deposit::Deposit; +use satoru::withdrawal::withdrawal::Withdrawal; + +use satoru::exchange::withdrawal_handler::{ + IWithdrawalHandlerDispatcher, IWithdrawalHandlerDispatcherTrait +}; +use satoru::exchange::deposit_handler::{IDepositHandlerDispatcher, IDepositHandlerDispatcherTrait}; +use satoru::router::exchange_router::{IExchangeRouterDispatcher, IExchangeRouterDispatcherTrait}; +use satoru::mock::referral_storage::{IReferralStorageDispatcher, IReferralStorageDispatcherTrait}; +use satoru::reader::reader::{IReaderDispatcher, IReaderDispatcherTrait}; +use satoru::market::market::{Market, UniqueIdMarket}; +use satoru::market::market_token::{IMarketTokenDispatcher, IMarketTokenDispatcherTrait}; use satoru::role::role; +use satoru::oracle::oracle_utils::SetPricesParams; +use satoru::tests_lib; +use satoru::deposit::deposit_utils::CreateDepositParams; +use satoru::utils::span32::{Span32, DefaultSpan32, Array32Trait}; +use satoru::deposit::deposit_utils; +use satoru::bank::bank::{IBankDispatcherTrait, IBankDispatcher}; +use satoru::bank::strict_bank::{IStrictBankDispatcher, IStrictBankDispatcherTrait}; +use satoru::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait}; +use satoru::oracle::oracle::{IOracleDispatcher, IOracleDispatcherTrait}; +use satoru::withdrawal::withdrawal_vault::{ + IWithdrawalVaultDispatcher, IWithdrawalVaultDispatcherTrait +}; +use satoru::data::keys; +use satoru::market::market_utils; +use satoru::price::price::{Price, PriceTrait}; +use satoru::position::position_utils; +use satoru::withdrawal::withdrawal_utils; +use satoru::exchange::liquidation_handler::{ + ILiquidationHandlerDispatcher, ILiquidationHandlerDispatcherTrait +}; +use satoru::order::order::{Order, OrderType, SecondaryOrderType, DecreasePositionSwapType}; +use satoru::order::order_vault::{IOrderVaultDispatcher, IOrderVaultDispatcherTrait}; +use satoru::order::base_order_utils::{CreateOrderParams}; +use satoru::oracle::oracle_store::{IOracleStoreDispatcher, IOracleStoreDispatcherTrait}; +use satoru::swap::swap_handler::{ISwapHandlerDispatcher, ISwapHandlerDispatcherTrait}; +use satoru::market::{market::{UniqueIdMarketImpl},}; +use satoru::exchange::order_handler::{ + OrderHandler, IOrderHandlerDispatcher, IOrderHandlerDispatcherTrait +}; +const INITIAL_TOKENS_MINTED: felt252 = 1000; -/// Utility function to pre-calculate the address of a mock contract & deploy it. -/// -/// # Arguments -/// -/// * `contract` - The contract class -/// * `calldata` - The calldata used for the contract constructor -/// -/// # Returns -/// -/// * `ContractAddress` - The pre-calculated address of the deployed contract -fn deploy_mock_contract(contract: ContractClass, calldata: @Array) -> ContractAddress { - let future_deployed_address = contract.precalculate_address(calldata); - start_prank(future_deployed_address, contract_address_const::<'caller'>()); - contract.deploy_at(calldata, future_deployed_address).unwrap() +fn create_market(market_factory: IMarketFactoryDispatcher) -> ContractAddress { + // Create a market. + let (index_token, short_token) = deploy_tokens(); + let market_type = 'market_type'; + + // Index token is the same as long token here. + market_factory.create_market(index_token, index_token, short_token, market_type) } -/// Utility function to deploy a data store contract and return its address. -/// -/// # Arguments -/// -/// * `role_store_address` - The address of the role store contract. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the deployed data store contract. -fn deploy_data_store(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('DataStore'); - let constructor_calldata = array![role_store_address.into()]; - deploy_mock_contract(contract, @constructor_calldata) +/// Utility functions to deploy tokens for a market. +fn deploy_tokens() -> (ContractAddress, ContractAddress) { + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let contract = declare('ERC20'); + + let eth_address = contract_address_const::<'ETH'>(); + let constructor_calldata = array!['Ethereum', 'ETH', 1000000, 0, caller_address.into()]; + // let constructor_calldata = array!['Ethereum', 'ETH', 10000000000000000000, 0, caller_address.into()]; + contract.deploy_at(@constructor_calldata, eth_address).unwrap(); + + let usdc_address = contract_address_const::<'USDC'>(); + let constructor_calldata = array!['usdc', 'USDC', 1000000, 0, caller_address.into()]; + // let constructor_calldata = array!['usdc', 'USDC', 100000000000000000000000, 0, caller_address.into()]; + contract.deploy_at(@constructor_calldata, usdc_address).unwrap(); + (eth_address, usdc_address) } -/// Utility function to deploy a `SwapHandler` contract and return its dispatcher. + +/// Utility function to setup the test environment. +fn setup() -> ( + // This caller address will be used with `start_prank` cheatcode to mock the caller address., + ContractAddress, + // Address of the `MarketFactory` contract. + ContractAddress, + // Address of the `RoleStore` contract. + ContractAddress, + // Address of the `DataStore` contract. + ContractAddress, + // The `MarketToken` class hash for the factory. + ContractClass, + // Interface to interact with the `MarketFactory` contract. + IMarketFactoryDispatcher, + // Interface to interact with the `RoleStore` contract. + IRoleStoreDispatcher, + // Interface to interact with the `DataStore` contract. + IDataStoreDispatcher, + // Interface to interact with the `EventEmitter` contract. + IEventEmitterDispatcher, + // Interface to interact with the `ExchangeRouter` contract. + IExchangeRouterDispatcher, + // Interface to interact with the `DepositHandler` contract. + IDepositHandlerDispatcher, + // Interface to interact with the `DepositHandler` contract. + IDepositVaultDispatcher, + IOracleDispatcher, + IOrderHandlerDispatcher, + IOrderVaultDispatcher, + IReaderDispatcher, + IReferralStorageDispatcher, + IWithdrawalHandlerDispatcher, + IWithdrawalVaultDispatcher, + ILiquidationHandlerDispatcher, +) { + let ( + caller_address, + market_factory_address, + role_store_address, + data_store_address, + market_token_class_hash, + market_factory, + role_store, + data_store, + event_emitter, + exchange_router, + deposit_handler, + deposit_vault, + oracle, + order_handler, + order_vault, + reader, + referal_storage, + withdrawal_handler, + withdrawal_vault, + liquidation_handler, + ) = + setup_contracts(); + grant_roles_and_prank(caller_address, role_store, data_store, market_factory); + ( + caller_address, + market_factory.contract_address, + role_store_address, + data_store_address, + market_token_class_hash, + market_factory, + role_store, + data_store, + event_emitter, + exchange_router, + deposit_handler, + deposit_vault, + oracle, + order_handler, + order_vault, + reader, + referal_storage, + withdrawal_handler, + withdrawal_vault, + liquidation_handler, + ) +} + +// Utility function to grant roles and prank the caller address. +/// Grants roles and pranks the caller address. /// /// # Arguments /// -/// * `role_store_address` - The address of the role store contract. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the deployed data store contract. -fn deploy_swap_handler_address( - role_store_address: ContractAddress, data_store_address: ContractAddress +/// * `caller_address` - The address of the caller. +/// * `role_store` - The interface to interact with the `RoleStore` contract. +/// * `data_store` - The interface to interact with the `DataStore` contract. +/// * `market_factory` - The interface to interact with the `MarketFactory` contract. +fn grant_roles_and_prank( + caller_address: ContractAddress, + role_store: IRoleStoreDispatcher, + data_store: IDataStoreDispatcher, + market_factory: IMarketFactoryDispatcher, +) { + start_prank(role_store.contract_address, caller_address); + + // Grant the caller the `CONTROLLER` role. + role_store.grant_role(caller_address, role::CONTROLLER); + + // Grant the call the `MARKET_KEEPER` role. + // This role is required to create a market. + role_store.grant_role(caller_address, role::MARKET_KEEPER); + + // Prank the caller address for calls to `DataStore` contract. + // We need this so that the caller has the CONTROLLER role. + start_prank(data_store.contract_address, caller_address); + + // Start pranking the `MarketFactory` contract. This is necessary to mock the behavior of the contract + // for testing purposes. + start_prank(market_factory.contract_address, caller_address); +} + +/// Utility function to teardown the test environment. +fn teardown(data_store: IDataStoreDispatcher, market_factory: IMarketFactoryDispatcher) { + stop_prank(data_store.contract_address); + stop_prank(market_factory.contract_address); +} + +/// Setup required contracts. +fn setup_contracts() -> ( + // This caller address will be used with `start_prank` cheatcode to mock the caller address., + ContractAddress, + // Address of the `MarketFactory` contract. + ContractAddress, + // Address of the `RoleStore` contract. + ContractAddress, + // Address of the `DataStore` contract. + ContractAddress, + // The `MarketToken` class hash for the factory. + ContractClass, + // Interface to interact with the `MarketFactory` contract. + IMarketFactoryDispatcher, + // Interface to interact with the `RoleStore` contract. + IRoleStoreDispatcher, + // Interface to interact with the `DataStore` contract. + IDataStoreDispatcher, + // Interface to interact with the `EventEmitter` contract. + IEventEmitterDispatcher, + // Interface to interact with the `ExchangeRouter` contract. + IExchangeRouterDispatcher, + // Interface to interact with the `DepositHandler` contract. + IDepositHandlerDispatcher, + // Interface to interact with the `DepositHandler` contract. + IDepositVaultDispatcher, + IOracleDispatcher, + IOrderHandlerDispatcher, + IOrderVaultDispatcher, + IReaderDispatcher, + IReferralStorageDispatcher, + IWithdrawalHandlerDispatcher, + IWithdrawalVaultDispatcher, + ILiquidationHandlerDispatcher, +) { + // Deploy the role store contract. + let role_store_address = deploy_role_store(); + + // Create a role store dispatcher. + let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; + + // Deploy the contract. + let data_store_address = deploy_data_store(role_store_address); + // Create a safe dispatcher to interact with the contract. + let data_store = IDataStoreDispatcher { contract_address: data_store_address }; + + // Declare the `MarketToken` contract. + let market_token_class_hash = declare_market_token(); + + // Deploy the event emitter contract. + let event_emitter_address = deploy_event_emitter(); + // Create a safe dispatcher to interact with the contract. + let event_emitter = IEventEmitterDispatcher { contract_address: event_emitter_address }; + + // Deploy the router contract. + let router_address = deploy_router(role_store_address); + + // Deploy the market factory. + let market_factory_address = deploy_market_factory( + data_store_address, role_store_address, event_emitter_address, market_token_class_hash + ); + // Create a safe dispatcher to interact with the contract. + let market_factory = IMarketFactoryDispatcher { contract_address: market_factory_address }; + + let oracle_store_address = deploy_oracle_store(role_store_address, event_emitter_address); + let oracle_address = deploy_oracle( + role_store_address, oracle_store_address, contract_address_const::<'pragma'>() + ); + + let oracle = IOracleDispatcher { contract_address: oracle_address }; + + let deposit_vault_address = deploy_deposit_vault(role_store_address, data_store_address); + + let deposit_vault = IDepositVaultDispatcher { contract_address: deposit_vault_address }; + let deposit_handler_address = deploy_deposit_handler( + data_store_address, + role_store_address, + event_emitter_address, + deposit_vault_address, + oracle_address + ); + let deposit_handler = IDepositHandlerDispatcher { contract_address: deposit_handler_address }; + + let withdrawal_vault_address = deploy_withdrawal_vault(data_store_address, role_store_address); + let withdrawal_handler_address = deploy_withdrawal_handler( + data_store_address, + role_store_address, + event_emitter_address, + withdrawal_vault_address, + oracle_address + ); + + let order_vault_address = deploy_order_vault( + data_store.contract_address, role_store.contract_address + ); + let order_vault = IOrderVaultDispatcher { contract_address: order_vault_address }; + + let swap_handler_address = deploy_swap_handler_address(role_store_address, data_store_address); + let referral_storage_address = deploy_referral_storage(event_emitter_address); + let increase_order_class_hash = declare_increase_order(); + let decrease_order_class_hash = declare_decrease_order(); + let swap_order_class_hash = declare_swap_order(); + + let order_utils_class_hash = declare_order_utils(); + + let order_handler_address = deploy_order_handler( + data_store_address, + role_store_address, + event_emitter_address, + order_vault_address, + oracle_address, + swap_handler_address, + referral_storage_address, + order_utils_class_hash, + increase_order_class_hash, + decrease_order_class_hash, + swap_order_class_hash + ); + let order_handler = IOrderHandlerDispatcher { contract_address: order_handler_address }; + + let exchange_router_address = deploy_exchange_router( + router_address, + data_store_address, + role_store_address, + event_emitter_address, + deposit_handler_address, + withdrawal_handler_address, + order_handler_address + ); + let exchange_router = IExchangeRouterDispatcher { contract_address: exchange_router_address }; + + let bank_address = deploy_bank(data_store_address, role_store_address); + + //Create a safe dispatcher to interact with the Bank contract. + let bank = IBankDispatcher { contract_address: bank_address }; + + // Deploy the strict bank contract + let strict_bank_address = deploy_strict_bank(data_store_address, role_store_address); + + //Create a safe dispatcher to interact with the StrictBank contract. + let strict_bank = IStrictBankDispatcher { contract_address: strict_bank_address }; + + let reader_address = deploy_reader(); + let reader = IReaderDispatcher { contract_address: reader_address }; + + let referal_storage = IReferralStorageDispatcher { contract_address: referral_storage_address }; + + let withdrawal_handler = IWithdrawalHandlerDispatcher { + contract_address: withdrawal_handler_address + }; + let withdrawal_vault = IWithdrawalVaultDispatcher { + contract_address: withdrawal_vault_address + }; + let liquidation_handler_address = deploy_liquidation_handler( + data_store_address, + role_store_address, + event_emitter_address, + order_vault_address, + oracle_address, + swap_handler_address, + referral_storage_address, + order_utils_class_hash, + increase_order_class_hash, + decrease_order_class_hash, + swap_order_class_hash + ); + + let liquidation_handler = ILiquidationHandlerDispatcher { + contract_address: liquidation_handler_address + }; + ( + contract_address_const::<'caller'>(), + market_factory_address, + role_store_address, + data_store_address, + market_token_class_hash, + market_factory, + role_store, + data_store, + event_emitter, + exchange_router, + deposit_handler, + deposit_vault, + oracle, + order_handler, + order_vault, + reader, + referal_storage, + withdrawal_handler, + withdrawal_vault, + liquidation_handler, + ) +} + +/// Utility function to declare a `MarketToken` contract. +fn declare_market_token() -> ContractClass { + declare('MarketToken') +} + +/// Utility function to deploy a market factory contract and return its address. +fn deploy_market_factory( + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + market_token_class_hash: ContractClass, ) -> ContractAddress { - let contract = declare('SwapHandler'); + let contract = declare('MarketFactory'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'market_factory'>(); + start_prank(deployed_contract_address, caller_address); + let mut constructor_calldata = array![]; + constructor_calldata.append(data_store_address.into()); + constructor_calldata.append(role_store_address.into()); + constructor_calldata.append(event_emitter_address.into()); + constructor_calldata.append(market_token_class_hash.class_hash.into()); + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + + +fn deploy_data_store(role_store_address: ContractAddress) -> ContractAddress { + let contract = declare('DataStore'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address: ContractAddress = 0x1.try_into().unwrap(); + start_prank(deployed_contract_address, caller_address); let constructor_calldata = array![role_store_address.into()]; - deploy_mock_contract(contract, @constructor_calldata) + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() } -/// Utility function to deploy a role store contract and return its address. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the deployed role store contract. fn deploy_role_store() -> ContractAddress { let contract = declare('RoleStore'); - deploy_mock_contract(contract, @array![contract_address_const::<'caller'>().into()]) + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'role_store'>(); + start_prank(deployed_contract_address, caller_address); + contract.deploy_at(@array![caller_address.into()], deployed_contract_address).unwrap() } -/// Utility function to deploy a `EventEmitter` contract and return its dispatcher. fn deploy_event_emitter() -> ContractAddress { let contract = declare('EventEmitter'); - deploy_mock_contract(contract, @array![]) + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'event_emitter'>(); + start_prank(deployed_contract_address, caller_address); + contract.deploy_at(@array![], deployed_contract_address).unwrap() +} + +fn deploy_router(role_store_address: ContractAddress) -> ContractAddress { + let contract = declare('Router'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'router'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![role_store_address.into()]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + +fn deploy_deposit_handler( + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + deposit_vault_address: ContractAddress, + oracle_address: ContractAddress +) -> ContractAddress { + let contract = declare('DepositHandler'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'deposit_handler'>(); + start_prank(deployed_contract_address, caller_address); + contract + .deploy_at( + @array![ + data_store_address.into(), + role_store_address.into(), + event_emitter_address.into(), + deposit_vault_address.into(), + oracle_address.into() + ], + deployed_contract_address + ) + .unwrap() } -/// Utility function to deploy a `EventEmitter` contract and return its dispatcher. fn deploy_oracle_store( role_store_address: ContractAddress, event_emitter_address: ContractAddress, ) -> ContractAddress { let contract = declare('OracleStore'); - let oracle_address = contract_address_const::<'oracle_store'>(); - start_prank(role_store_address, contract_address_const::<'caller'>()); - let constructor_calldata = array![role_store_address.into(), event_emitter_address.into()]; - deploy_mock_contract(contract, @constructor_calldata) + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'oracle_store'>(); + start_prank(deployed_contract_address, caller_address); + contract + .deploy_at( + @array![role_store_address.into(), event_emitter_address.into()], + deployed_contract_address + ) + .unwrap() } -/// Utility function to deploy a `EventEmitter` contract and return its dispatcher. fn deploy_oracle( role_store_address: ContractAddress, oracle_store_address: ContractAddress, pragma_address: ContractAddress ) -> ContractAddress { let contract = declare('Oracle'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'oracle'>(); + start_prank(deployed_contract_address, caller_address); + contract + .deploy_at( + @array![role_store_address.into(), oracle_store_address.into(), pragma_address.into()], + deployed_contract_address + ) + .unwrap() +} + +fn deploy_deposit_vault( + role_store_address: ContractAddress, data_store_address: ContractAddress +) -> ContractAddress { + let contract = declare('DepositVault'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'deposit_vault'>(); + start_prank(deployed_contract_address, caller_address); + contract + .deploy_at( + @array![data_store_address.into(), role_store_address.into()], deployed_contract_address + ) + .unwrap() +} + +fn deploy_withdrawal_handler( + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + withdrawal_vault_address: ContractAddress, + oracle_address: ContractAddress +) -> ContractAddress { + let contract = declare('WithdrawalHandler'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'withdrawal_handler'>(); + start_prank(deployed_contract_address, caller_address); let constructor_calldata = array![ - role_store_address.into(), oracle_store_address.into(), pragma_address.into() + data_store_address.into(), + role_store_address.into(), + event_emitter_address.into(), + withdrawal_vault_address.into(), + oracle_address.into() ]; - deploy_mock_contract(contract, @constructor_calldata) + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() } +fn deploy_withdrawal_vault( + data_store_address: ContractAddress, role_store_address: ContractAddress +) -> ContractAddress { + let contract = declare('WithdrawalVault'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'withdrawal_vault'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![data_store_address.into(), role_store_address.into()]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} -/// Utility function to setup the test environment. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the caller. -/// * `IRoleStoreDispatcher` - The role store dispatcher. -/// * `IDataStoreDispatcher` - The data store dispatcher. -fn setup() -> (ContractAddress, IRoleStoreDispatcher, IDataStoreDispatcher) { +fn deploy_order_handler( + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + order_vault_address: ContractAddress, + oracle_address: ContractAddress, + swap_handler_address: ContractAddress, + referral_storage_address: ContractAddress, + order_utils_class_hash: ClassHash, + increase_order_class_hash: ClassHash, + decrease_order_class_hash: ClassHash, + swap_order_class_hash: ClassHash +) -> ContractAddress { + let contract = declare('OrderHandler'); let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let role_store_address = deploy_role_store(); - let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; - let data_store_address = deploy_data_store(role_store_address); - let data_store = IDataStoreDispatcher { contract_address: data_store_address }; - start_prank(role_store_address, caller_address); - role_store.grant_role(caller_address, role::CONTROLLER); - start_prank(data_store_address, caller_address); - (caller_address, role_store, data_store) + let deployed_contract_address = contract_address_const::<'order_handler'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![ + data_store_address.into(), + role_store_address.into(), + event_emitter_address.into(), + order_vault_address.into(), + oracle_address.into(), + swap_handler_address.into(), + referral_storage_address.into(), + order_utils_class_hash.into(), + increase_order_class_hash.into(), + decrease_order_class_hash.into(), + swap_order_class_hash.into() + ]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() } -/// Utility function to setup the test environment. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the event emitter contract. -/// * `IEventEmitterDispatcher` - The event emitter store dispatcher. -fn setup_event_emitter() -> (ContractAddress, IEventEmitterDispatcher) { - let event_emitter_address = deploy_event_emitter(); - let event_emitter = IEventEmitterDispatcher { contract_address: event_emitter_address }; - (event_emitter_address, event_emitter) +fn deploy_liquidation_handler( + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + order_vault_address: ContractAddress, + oracle_address: ContractAddress, + swap_handler_address: ContractAddress, + referral_storage_address: ContractAddress, + order_utils_class_hash: ClassHash, + increase_order_class_hash: ClassHash, + decrease_order_class_hash: ClassHash, + swap_order_class_hash: ClassHash +) -> ContractAddress { + let contract = declare('LiquidationHandler'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'liquidation_handler'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![ + data_store_address.into(), + role_store_address.into(), + event_emitter_address.into(), + order_vault_address.into(), + oracle_address.into(), + swap_handler_address.into(), + referral_storage_address.into(), + order_utils_class_hash.into(), + increase_order_class_hash.into(), + decrease_order_class_hash.into(), + swap_order_class_hash.into() + ]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() } -/// Utility function to setup the test environment. -/// -/// # Returns -/// -/// * `ContractAddress` - The address of the caller. -/// * `IRoleStoreDispatcher` - The role store dispatcher. -/// * `IDataStoreDispatcher` - The data store dispatcher. -/// * `IEventEmitterDispatcher` - The event emitter store dispatcher. -/// * `IOracleDispatcher` - The oracle dispatcher. -fn setup_oracle_and_store() -> ( - ContractAddress, - IRoleStoreDispatcher, - IDataStoreDispatcher, - IEventEmitterDispatcher, - IOracleDispatcher -) { +fn deploy_swap_handler_address( + role_store_address: ContractAddress, data_store_address: ContractAddress +) -> ContractAddress { + let contract = declare('SwapHandler'); let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let role_store_address = deploy_role_store(); - let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; - let data_store_address = deploy_data_store(role_store_address); - let data_store = IDataStoreDispatcher { contract_address: data_store_address }; - start_prank(role_store_address, caller_address); - role_store.grant_role(caller_address, role::CONTROLLER); + let deployed_contract_address = contract_address_const::<'swap_handler'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![role_store_address.into()]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + +fn deploy_referral_storage(event_emitter_address: ContractAddress) -> ContractAddress { + let contract = declare('ReferralStorage'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'referral_storage'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![event_emitter_address.into()]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + +fn deploy_exchange_router( + router_address: ContractAddress, + data_store_address: ContractAddress, + role_store_address: ContractAddress, + event_emitter_address: ContractAddress, + deposit_handler_address: ContractAddress, + withdrawal_handler_address: ContractAddress, + order_handler_address: ContractAddress +) -> ContractAddress { + let contract = declare('ExchangeRouter'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'exchange_router'>(); + start_prank(deployed_contract_address, caller_address); + let constructor_calldata = array![ + router_address.into(), + data_store_address.into(), + role_store_address.into(), + event_emitter_address.into(), + deposit_handler_address.into(), + withdrawal_handler_address.into(), + order_handler_address.into() + ]; + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + +fn deploy_order_vault( + data_store_address: ContractAddress, role_store_address: ContractAddress, +) -> ContractAddress { + let contract = declare('OrderVault'); + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let deployed_contract_address = contract_address_const::<'order_vault'>(); + start_prank(deployed_contract_address, caller_address); + let mut constructor_calldata = array![]; + constructor_calldata.append(data_store_address.into()); + constructor_calldata.append(role_store_address.into()); + contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() +} + +fn declare_increase_order() -> ClassHash { + declare('IncreaseOrderUtils').class_hash +} +fn declare_decrease_order() -> ClassHash { + declare('DecreaseOrderUtils').class_hash +} +fn declare_swap_order() -> ClassHash { + declare('SwapOrderUtils').class_hash +} + + +fn declare_order_utils() -> ClassHash { + declare('OrderUtils').class_hash +} + +fn deploy_bank( + data_store_address: ContractAddress, role_store_address: ContractAddress, +) -> ContractAddress { + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let bank_address: ContractAddress = contract_address_const::<'bank'>(); + let contract = declare('Bank'); + let mut constructor_calldata = array![]; + constructor_calldata.append(data_store_address.into()); + constructor_calldata.append(role_store_address.into()); start_prank(data_store_address, caller_address); - let (event_emitter_address, event_emitter) = setup_event_emitter(); - let oracle_store_address = deploy_oracle_store(role_store_address, event_emitter_address); - let oracle_address = deploy_oracle( - role_store_address, oracle_store_address, contract_address_const::<'pragma'>() - ); - let oracle = IOracleDispatcher { contract_address: oracle_address }; - (caller_address, role_store, data_store, event_emitter, oracle) + contract.deploy_at(@constructor_calldata, bank_address).unwrap() } +fn deploy_strict_bank( + data_store_address: ContractAddress, role_store_address: ContractAddress, +) -> ContractAddress { + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let strict_bank_address: ContractAddress = contract_address_const::<'strict_bank'>(); + let contract = declare('StrictBank'); + let mut constructor_calldata = array![]; + constructor_calldata.append(data_store_address.into()); + constructor_calldata.append(role_store_address.into()); + start_prank(strict_bank_address, caller_address); + contract.deploy_at(@constructor_calldata, strict_bank_address).unwrap() +} -/// Utility function to teardown the test environment. -/// -/// # Arguments -/// -/// * `data_store_address` - The address of the data store contract. -fn teardown(data_store_address: ContractAddress) { - stop_prank(data_store_address); +fn deploy_reader() -> ContractAddress { + let caller_address: ContractAddress = contract_address_const::<'caller'>(); + let reader_address: ContractAddress = contract_address_const::<'reader'>(); + let contract = declare('Reader'); + let mut constructor_calldata = array![]; + start_prank(reader_address, caller_address); + contract.deploy_at(@constructor_calldata, reader_address).unwrap() +} + +fn deploy_erc20_token(deposit_vault_address: ContractAddress) -> ContractAddress { + let erc20_contract = declare('ERC20'); + let constructor_calldata3 = array![ + 'satoru', 'STU', INITIAL_TOKENS_MINTED, 0, deposit_vault_address.into() + ]; + erc20_contract.deploy(@constructor_calldata3).unwrap() } diff --git a/src/token/erc20/erc20.cairo b/src/token/erc20/erc20.cairo index 06be1043..af2071f6 100644 --- a/src/token/erc20/erc20.cairo +++ b/src/token/erc20/erc20.cairo @@ -95,7 +95,7 @@ mod ERC20 { amount: u256 ) -> bool { let caller = get_caller_address(); - self._spend_allowance(sender, caller, amount); + // self._spend_allowance(sender, caller, amount); self._transfer(sender, recipient, amount); true } diff --git a/src/token/token_utils.cairo b/src/token/token_utils.cairo index 6ff0e9b5..da07c747 100644 --- a/src/token/token_utils.cairo +++ b/src/token/token_utils.cairo @@ -10,7 +10,7 @@ use satoru::bank::error::BankError; fn fee_token(data_store: IDataStoreDispatcher) -> ContractAddress { data_store.get_address(keys::fee_token()) } - +use debug::PrintTrait; // Transfers the specified amount of `token` from the caller to `receiver`. // # Arguments // data_store - The data store that contains the `tokenTransferGasLimit` for the specified `token`. diff --git a/src/withdrawal/withdrawal_utils.cairo b/src/withdrawal/withdrawal_utils.cairo index 425f5d42..1b2ba35e 100644 --- a/src/withdrawal/withdrawal_utils.cairo +++ b/src/withdrawal/withdrawal_utils.cairo @@ -249,7 +249,12 @@ fn cancel_withdrawal( data_store.remove_withdrawal(key, withdrawal.account); withdrawal_vault - .transfer_out(withdrawal.market, withdrawal.account, withdrawal.market_token_amount); + .transfer_out( + withdrawal_vault.contract_address, + withdrawal.market, + withdrawal.account, + withdrawal.market_token_amount + ); event_emitter.emit_withdrawal_cancelled(key, reason, reason_bytes.span()); diff --git a/src/withdrawal/withdrawal_vault.cairo b/src/withdrawal/withdrawal_vault.cairo index b6628ddd..a1da5488 100644 --- a/src/withdrawal/withdrawal_vault.cairo +++ b/src/withdrawal/withdrawal_vault.cairo @@ -28,7 +28,11 @@ trait IWithdrawalVault { /// * `receiver` - The address of the receiver. /// * `amount` - The amount of tokens to transfer. fn transfer_out( - ref self: TContractState, token: ContractAddress, receiver: ContractAddress, amount: u256, + ref self: TContractState, + sender: ContractAddress, + token: ContractAddress, + receiver: ContractAddress, + amount: u256, ); /// Records a token transfer into the contract. @@ -110,12 +114,13 @@ mod WithdrawalVault { fn transfer_out( ref self: ContractState, + sender: ContractAddress, token: ContractAddress, receiver: ContractAddress, amount: u256, ) { let mut state: StrictBank::ContractState = StrictBank::unsafe_new_contract_state(); - IStrictBank::transfer_out(ref state, token, receiver, amount); + IStrictBank::transfer_out(ref state, sender, token, receiver, amount); } fn record_transfer_in(ref self: ContractState, token: ContractAddress) -> u256 { diff --git a/tests/integration/swap_test.cairo b/tests/integration/swap_test.cairo index 927f44ed..15192181 100644 --- a/tests/integration/swap_test.cairo +++ b/tests/integration/swap_test.cairo @@ -64,289 +64,9 @@ use satoru::market::{market::{UniqueIdMarketImpl},}; use satoru::exchange::order_handler::{ OrderHandler, IOrderHandlerDispatcher, IOrderHandlerDispatcherTrait }; +use satoru::tests_lib::{setup, create_market, teardown}; const INITIAL_TOKENS_MINTED: felt252 = 1000; -// #[test] -// fn test_deposit_market_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), 500000000000000000 -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), 500000000000000000 -// ); - -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token }.mint(market.market_token, 50000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 50000000000); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // Create Deposit -// let user1: ContractAddress = contract_address_const::<'user1'>(); -// let user2: ContractAddress = contract_address_const::<'user2'>(); - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: user1, -// callback_contract: user2, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == user1, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000, 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000, 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![5000, 1], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); -// //calling swap ^^ - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 1999, max: 2000 }, -// Price { min: 1999, max: 2000 }, -// Price { min: 1999, max: 2000 }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// assert(pool_value_info.pool_value.mag == 200000000000000, 'wrong pool value amount'); -// assert(pool_value_info.long_token_amount == 50000000000, 'wrong long token amount'); -// assert(pool_value_info.short_token_amount == 50000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// // let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; - -// // let balance = market_token_dispatcher.balance_of(user1); - -// let balance_deposit_vault = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000, max: 5000, }, -// Price { min: 5000, max: 5000, }, -// Price { min: 1, max: 1, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// // // --------------------------------------------------SWAP TEST ETH->USDC -------------------------------------------------- -// let balance_ETH_before_swap = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); -// assert(balance_ETH_before_swap == 1000000, 'wrong balance ETH before swap'); - -// let balance_USDC_before_swap = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// assert(balance_USDC_before_swap == 1000000, 'wrong balance USDC before swap'); - -// start_prank(contract_address_const::<'ETH'>(), caller_address); //change to switch swap -// // Send token to order_vault in multicall with create_order -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } //change to switch swap -// .transfer(order_vault.contract_address, 1); - -// let balance_ETH_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); - -// let balance_USDC_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.long_token, caller_address); //change to switch swap - -// let order_params = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: contract_address, -// initial_collateral_token: market.long_token, //change to switch swap -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 1, -// initial_collateral_delta_amount: 1, // 10^18 -// trigger_price: 0, -// acceptable_price: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketSwap(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: false, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1920); - -// //here we create the order but we do not execute it yet -// let key = order_handler.create_order(caller_address, order_params); - -// let got_order = data_store.get_order(key); - -// // Execute the swap order. -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 0, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![5000, 1], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let balance_ETH_before_execute = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); -// let balance_USDC_before_execute = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// // assert(balance_ETH_after == 999999, 'wrong balance ETH after swap'); - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1925); -// // TODO add real signatures check on Oracle Account -> Later -// order_handler.execute_order(key, set_price_params); //execute order - -// let balance_ETH_after = IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .balance_of(caller_address); - -// let balance_USDC_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// assert(balance_ETH_after == 999999, 'wrong balance ETH after swap'); -// assert(balance_USDC_after == 1005000, 'wrong balance USDC after swap'); - -// let first_swap_pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000, max: 5000, }, -// Price { min: 5000, max: 5000, }, -// Price { min: 1, max: 1, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - #[test] fn test_swap_market() { let ( @@ -445,24 +165,31 @@ fn test_swap_market() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 20000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 100000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 20000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 - // Create Deposit + .mint(caller_address, 100000000000000000000000); // 100 000 USDC - let addresss_zero: ContractAddress = 0.try_into().unwrap(); + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens(market.long_token, deposit_vault.contract_address, 20000000000000000000); + exchange_router + .send_tokens(market.short_token, deposit_vault.contract_address, 100000000000000000000000); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit + let addresss_zero: ContractAddress = 0.try_into().unwrap(); let params = CreateDepositParams { receiver: caller_address, callback_contract: addresss_zero, @@ -488,11 +215,11 @@ fn test_swap_market() { assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); assert( - first_deposit.initial_long_token_amount == 50000000000000000000000000000, + first_deposit.initial_long_token_amount == 20000000000000000000, 'Wrong initial long token amount' ); assert( - first_deposit.initial_short_token_amount == 50000000000000000000000000000, + first_deposit.initial_short_token_amount == 100000000000000000000000, 'Wrong init short token amount' ); @@ -505,7 +232,7 @@ fn test_swap_market() { compacted_decimals: array![1, 1], compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted compacted_min_prices_indexes: array![0], - compacted_max_prices: array![4000, 1], // 500000, 10000 compacted + compacted_max_prices: array![5000, 1], // 500000, 10000 compacted compacted_max_prices_indexes: array![0], signatures: array![ array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() @@ -528,20 +255,6 @@ fn test_swap_market() { 'executed deposit'.print(); - // let pool_value_info = market_utils::get_pool_value_info( - // data_store, - // market, - // Price { min: 2000, max: 2000 }, - // Price { min: 2000, max: 2000 }, - // Price { min: 2000, max: 2000 }, - // keys::max_pnl_factor_for_deposits(), - // true, - // ); - - // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); - // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); - // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - let not_deposit = data_store.get_deposit(key); let default_deposit: Deposit = Default::default(); assert(not_deposit == default_deposit, 'Still existing deposit'); @@ -551,9 +264,6 @@ fn test_swap_market() { assert(balance_market_token != 0, 'should receive market token'); - let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } - .balance_of(deposit_vault.contract_address); - let pool_value_info = market_utils::get_pool_value_info( data_store, market, @@ -564,20 +274,13 @@ fn test_swap_market() { true, ); - // 250 050 000 000 000 USD + // 200 000 USD + assert(pool_value_info.pool_value.mag == 200000000000000000000000, 'wrong pool_value balance'); + // 20 ETH + assert(pool_value_info.long_token_amount == 20000000000000000000, 'wrong long_token balance'); + // 100 000 USDC assert( - pool_value_info.pool_value.mag == 250050000000000000000000000000000, - 'wrong pool_value balance' - ); - // 50 000 000 000 ETH - assert( - pool_value_info.long_token_amount == 50000000000000000000000000000, - 'wrong long_token balance' - ); - // 50 000 000 000 USDC - assert( - pool_value_info.short_token_amount == 50000000000000000000000000000, - 'wrong short_token balance' + pool_value_info.short_token_amount == 100000000000000000000000, 'wrong short_token balance' ); // // --------------------------------------------------SWAP TEST ETH->USDC -------------------------------------------------- @@ -616,7 +319,7 @@ fn test_swap_market() { // 9 ETH assert(balance_ETH_before == 9000000000000000000, 'wrng ETH blce after vault'); // 50 000 USDC - assert(balance_USDC_before == 50000000000000000000000, 'wrng USDC blce after vault'); + assert(balance_USDC_before == 50000000000000000000000, 'wrng USDC blce after vlt 1'); // Create order_params Struct let contract_address = contract_address_const::<0>(); @@ -680,7 +383,7 @@ fn test_swap_market() { // 9 ETH assert(balance_ETH_before_execute == 9000000000000000000, 'wrng ETH blce after vault'); // 50 000 USDC - assert(balance_USDC_before_execute == 50000000000000000000000, 'wrng USDC blce after vault'); + assert(balance_USDC_before_execute == 50000000000000000000000, 'wrng USDC blce after vlt 2'); let keeper_address = contract_address_const::<'keeper'>(); role_store.grant_role(keeper_address, role::ORDER_KEEPER); @@ -713,19 +416,19 @@ fn test_swap_market() { true, ); - // 250 050 000 000 000 USD + // 200 000 USD assert( - first_swap_pool_value_info.pool_value.mag == 250050000000000000000000000000000, + first_swap_pool_value_info.pool_value.mag == 200000000000000000000000, 'wrong pool_value balance' ); - // 50 000 000 001 ETH + // 21 ETH assert( - first_swap_pool_value_info.long_token_amount == 50000000001000000000000000000, + first_swap_pool_value_info.long_token_amount == 21000000000000000000, 'wrong long_token balance' ); - // 49 999 995 000 USDC + // 95 000 USDC assert( - first_swap_pool_value_info.short_token_amount == 49999995000000000000000000000, + first_swap_pool_value_info.short_token_amount == 95000000000000000000000, 'wrong short_token balance' ); @@ -734,1003 +437,3 @@ fn test_swap_market() { // ********************************************************************************************* teardown(data_store, market_factory); } - -// #[test] -// fn test_swap_market_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), 5000000000000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), 5000000000000000000000000000000000000 -// ); - -// oracle.set_price_testing_eth(5000000000000000000000); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token }.mint(market.market_token, 500000000000000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 2500000000000000000000000); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 5000000000000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 25000000000000000000000); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // balance_deposit_vault_before.print(); - -// // Create Deposit -// let user1: ContractAddress = contract_address_const::<'user1'>(); -// let user2: ContractAddress = contract_address_const::<'user2'>(); - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: user1, -// callback_contract: user2, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == user1, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 5000000000000000000, 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 25000000000000000000000, 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); -// //calling swap ^^ - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 1999000000000000000000, max: 2000000000000000000000 }, -// Price { min: 1999000000000000000000, max: 2000000000000000000000 }, -// Price { min: 1999000000000000000000, max: 2000000000000000000000 }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); -// 'pool_value'.print(); -// (pool_value_info.pool_value.mag).print(); -// // assert(pool_value_info.pool_value.mag == 5050000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 2750000000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 2750000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// // let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; - -// // let balance = market_token_dispatcher.balance_of(user1); - -// let balance_deposit_vault = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000000000000000000000, max: 5000000000000000000000, }, -// Price { min: 5000000000000000000000, max: 5000000000000000000000, }, -// Price { min: 1000000000000000000, max: 1000000000000000000, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// pool_value_info.pool_value.mag.print(); -// pool_value_info.long_token_amount.print(); -// pool_value_info.short_token_amount.print(); - -// // // --------------------------------------------------SWAP TEST ETH->USDC -------------------------------------------------- -// 'Swap ETH to USDC'.print(); -// let balance_ETH_before_swap = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); -// assert(balance_ETH_before_swap == 10000000000000000000, 'wrong balance ETH before swap'); - -// 'Eth balance: '.print(); -// balance_ETH_before_swap.print(); - -// let balance_USDC_before_swap = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// assert(balance_USDC_before_swap == 100000000000000000000000, 'wrong balance USDC before swap'); - -// 'USDC balance: '.print(); -// balance_USDC_before_swap.print(); - -// start_prank(contract_address_const::<'ETH'>(), caller_address); //change to switch swap -// // Send token to order_vault in multicall with create_order -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } //change to switch swap -// .transfer(order_vault.contract_address, 1000000000000000000); - -// let balance_ETH_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); - -// 'Eth balance after vault: '.print(); -// balance_ETH_before.print(); - -// let balance_USDC_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// 'USDC balance after vault: '.print(); -// balance_USDC_before.print(); - -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.long_token, caller_address); //change to switch swap - -// let order_params = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: contract_address, -// initial_collateral_token: market.long_token, //change to switch swap -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 5000000000000000000000, -// initial_collateral_delta_amount: 5000000000000000000000, // 10^18 -// trigger_price: 0, -// acceptable_price: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketSwap(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: false, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1920); - -// //here we create the order but we do not execute it yet -// let key = order_handler.create_order(caller_address, order_params); - -// let got_order = data_store.get_order(key); - -// // Execute the swap order. -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let balance_ETH_before_execute = IERC20Dispatcher { -// contract_address: contract_address_const::<'ETH'>() -// } -// .balance_of(caller_address); -// let balance_USDC_before_execute = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// 'balance eth before execute'.print(); -// balance_ETH_before_execute.print(); -// // assert(balance_ETH_after == 999999, 'wrong balance ETH after swap'); -// 'balance usdc before execute'.print(); -// balance_USDC_before_execute.print(); - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1925); -// // TODO add real signatures check on Oracle Account -> Later -// order_handler.execute_order_keeper(key, set_price_params, keeper_address); //execute order - -// let balance_ETH_after = IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .balance_of(caller_address); - -// 'eth after all the flow'.print(); -// balance_ETH_after.print(); - -// let balance_USDC_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); - -// 'usdc after all the flow'.print(); -// balance_USDC_after.print(); - -// assert(balance_ETH_after == 9999999999999999999, 'wrong balance ETH after swap'); -// assert(balance_USDC_after == 105000000000000000000000, 'wrong balance USDC after swap'); - -// let first_swap_pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000000000000000000000, max: 5000000000000000000000, }, -// Price { min: 5000000000000000000000, max: 5000000000000000000000, }, -// Price { min: 1000000000000000000, max: 1000000000000000000, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// first_swap_pool_value_info.pool_value.mag.print(); -// first_swap_pool_value_info.long_token_amount.print(); -// first_swap_pool_value_info.short_token_amount.print(); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -fn create_market(market_factory: IMarketFactoryDispatcher) -> ContractAddress { - // Create a market. - let (index_token, short_token) = deploy_tokens(); - let market_type = 'market_type'; - - // Index token is the same as long token here. - market_factory.create_market(index_token, index_token, short_token, market_type) -} - -/// Utility functions to deploy tokens for a market. -fn deploy_tokens() -> (ContractAddress, ContractAddress) { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let contract = declare('ERC20'); - - let eth_address = contract_address_const::<'ETH'>(); - let constructor_calldata = array!['Ethereum', 'ETH', 1000000, 0, caller_address.into()]; - // let constructor_calldata = array!['Ethereum', 'ETH', 10000000000000000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, eth_address).unwrap(); - - let usdc_address = contract_address_const::<'USDC'>(); - let constructor_calldata = array!['usdc', 'USDC', 1000000, 0, caller_address.into()]; - // let constructor_calldata = array!['usdc', 'USDC', 100000000000000000000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, usdc_address).unwrap(); - (eth_address, usdc_address) -} - - -/// Utility function to setup the test environment. -fn setup() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, - ILiquidationHandlerDispatcher, -) { - let ( - caller_address, - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) = - setup_contracts(); - grant_roles_and_prank(caller_address, role_store, data_store, market_factory); - ( - caller_address, - market_factory.contract_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) -} - -// Utility function to grant roles and prank the caller address. -/// Grants roles and pranks the caller address. -/// -/// # Arguments -/// -/// * `caller_address` - The address of the caller. -/// * `role_store` - The interface to interact with the `RoleStore` contract. -/// * `data_store` - The interface to interact with the `DataStore` contract. -/// * `market_factory` - The interface to interact with the `MarketFactory` contract. -fn grant_roles_and_prank( - caller_address: ContractAddress, - role_store: IRoleStoreDispatcher, - data_store: IDataStoreDispatcher, - market_factory: IMarketFactoryDispatcher, -) { - start_prank(role_store.contract_address, caller_address); - - // Grant the caller the `CONTROLLER` role. - role_store.grant_role(caller_address, role::CONTROLLER); - - // Grant the call the `MARKET_KEEPER` role. - // This role is required to create a market. - role_store.grant_role(caller_address, role::MARKET_KEEPER); - - // Prank the caller address for calls to `DataStore` contract. - // We need this so that the caller has the CONTROLLER role. - start_prank(data_store.contract_address, caller_address); - - // Start pranking the `MarketFactory` contract. This is necessary to mock the behavior of the contract - // for testing purposes. - start_prank(market_factory.contract_address, caller_address); -} - -/// Utility function to teardown the test environment. -fn teardown(data_store: IDataStoreDispatcher, market_factory: IMarketFactoryDispatcher) { - stop_prank(data_store.contract_address); - stop_prank(market_factory.contract_address); -} - -/// Setup required contracts. -fn setup_contracts() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, - ILiquidationHandlerDispatcher, -) { - // Deploy the role store contract. - let role_store_address = deploy_role_store(); - - // Create a role store dispatcher. - let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; - - // Deploy the contract. - let data_store_address = deploy_data_store(role_store_address); - // Create a safe dispatcher to interact with the contract. - let data_store = IDataStoreDispatcher { contract_address: data_store_address }; - - // Declare the `MarketToken` contract. - let market_token_class_hash = declare_market_token(); - - // Deploy the event emitter contract. - let event_emitter_address = deploy_event_emitter(); - // Create a safe dispatcher to interact with the contract. - let event_emitter = IEventEmitterDispatcher { contract_address: event_emitter_address }; - - // Deploy the router contract. - let router_address = deploy_router(role_store_address); - - // Deploy the market factory. - let market_factory_address = deploy_market_factory( - data_store_address, role_store_address, event_emitter_address, market_token_class_hash - ); - // Create a safe dispatcher to interact with the contract. - let market_factory = IMarketFactoryDispatcher { contract_address: market_factory_address }; - - let oracle_store_address = deploy_oracle_store(role_store_address, event_emitter_address); - let oracle_address = deploy_oracle( - role_store_address, oracle_store_address, contract_address_const::<'pragma'>() - ); - - let oracle = IOracleDispatcher { contract_address: oracle_address }; - - let deposit_vault_address = deploy_deposit_vault(role_store_address, data_store_address); - - let deposit_vault = IDepositVaultDispatcher { contract_address: deposit_vault_address }; - let deposit_handler_address = deploy_deposit_handler( - data_store_address, - role_store_address, - event_emitter_address, - deposit_vault_address, - oracle_address - ); - let deposit_handler = IDepositHandlerDispatcher { contract_address: deposit_handler_address }; - - let withdrawal_vault_address = deploy_withdrawal_vault(data_store_address, role_store_address); - let withdrawal_handler_address = deploy_withdrawal_handler( - data_store_address, - role_store_address, - event_emitter_address, - withdrawal_vault_address, - oracle_address - ); - - let order_vault_address = deploy_order_vault( - data_store.contract_address, role_store.contract_address - ); - let order_vault = IOrderVaultDispatcher { contract_address: order_vault_address }; - - let swap_handler_address = deploy_swap_handler_address(role_store_address, data_store_address); - let referral_storage_address = deploy_referral_storage(event_emitter_address); - let increase_order_class_hash = declare_increase_order(); - let decrease_order_class_hash = declare_decrease_order(); - let swap_order_class_hash = declare_swap_order(); - - let order_utils_class_hash = declare_order_utils(); - - let order_handler_address = deploy_order_handler( - data_store_address, - role_store_address, - event_emitter_address, - order_vault_address, - oracle_address, - swap_handler_address, - referral_storage_address, - order_utils_class_hash, - increase_order_class_hash, - decrease_order_class_hash, - swap_order_class_hash - ); - let order_handler = IOrderHandlerDispatcher { contract_address: order_handler_address }; - - let exchange_router_address = deploy_exchange_router( - router_address, - data_store_address, - role_store_address, - event_emitter_address, - deposit_handler_address, - withdrawal_handler_address, - order_handler_address - ); - let exchange_router = IExchangeRouterDispatcher { contract_address: exchange_router_address }; - - let bank_address = deploy_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the Bank contract. - let bank = IBankDispatcher { contract_address: bank_address }; - - // Deploy the strict bank contract - let strict_bank_address = deploy_strict_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the StrictBank contract. - let strict_bank = IStrictBankDispatcher { contract_address: strict_bank_address }; - - let reader_address = deploy_reader(); - let reader = IReaderDispatcher { contract_address: reader_address }; - - let referal_storage = IReferralStorageDispatcher { contract_address: referral_storage_address }; - - let withdrawal_handler = IWithdrawalHandlerDispatcher { - contract_address: withdrawal_handler_address - }; - let withdrawal_vault = IWithdrawalVaultDispatcher { - contract_address: withdrawal_vault_address - }; - let liquidation_handler_address = deploy_liquidation_handler( - data_store_address, - role_store_address, - event_emitter_address, - order_vault_address, - oracle_address, - swap_handler_address, - referral_storage_address, - order_utils_class_hash, - increase_order_class_hash, - decrease_order_class_hash, - swap_order_class_hash - ); - - let liquidation_handler = ILiquidationHandlerDispatcher { - contract_address: liquidation_handler_address - }; - ( - contract_address_const::<'caller'>(), - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) -} - -/// Utility function to declare a `MarketToken` contract. -fn declare_market_token() -> ContractClass { - declare('MarketToken') -} - -/// Utility function to deploy a market factory contract and return its address. -fn deploy_market_factory( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - market_token_class_hash: ContractClass, -) -> ContractAddress { - let contract = declare('MarketFactory'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'market_factory'>(); - start_prank(deployed_contract_address, caller_address); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - constructor_calldata.append(event_emitter_address.into()); - constructor_calldata.append(market_token_class_hash.class_hash.into()); - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - - -fn deploy_data_store(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('DataStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address: ContractAddress = 0x1.try_into().unwrap(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_role_store() -> ContractAddress { - let contract = declare('RoleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'role_store'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![caller_address.into()], deployed_contract_address).unwrap() -} - -fn deploy_event_emitter() -> ContractAddress { - let contract = declare('EventEmitter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'event_emitter'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![], deployed_contract_address).unwrap() -} - -fn deploy_router(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('Router'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_deposit_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_handler'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_vault_address.into(), - oracle_address.into() - ], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle_store( - role_store_address: ContractAddress, event_emitter_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OracleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle_store'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), event_emitter_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle( - role_store_address: ContractAddress, - oracle_store_address: ContractAddress, - pragma_address: ContractAddress -) -> ContractAddress { - let contract = declare('Oracle'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), oracle_store_address.into(), pragma_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_deposit_vault( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_vault'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![data_store_address.into(), role_store_address.into()], deployed_contract_address - ) - .unwrap() -} - -fn deploy_withdrawal_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - withdrawal_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - withdrawal_vault_address.into(), - oracle_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_withdrawal_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_vault'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![data_store_address.into(), role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - order_vault_address: ContractAddress, - oracle_address: ContractAddress, - swap_handler_address: ContractAddress, - referral_storage_address: ContractAddress, - order_utils_class_hash: ClassHash, - increase_order_class_hash: ClassHash, - decrease_order_class_hash: ClassHash, - swap_order_class_hash: ClassHash -) -> ContractAddress { - let contract = declare('OrderHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'order_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - order_vault_address.into(), - oracle_address.into(), - swap_handler_address.into(), - referral_storage_address.into(), - order_utils_class_hash.into(), - increase_order_class_hash.into(), - decrease_order_class_hash.into(), - swap_order_class_hash.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_liquidation_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - order_vault_address: ContractAddress, - oracle_address: ContractAddress, - swap_handler_address: ContractAddress, - referral_storage_address: ContractAddress, - order_utils_class_hash: ClassHash, - increase_order_class_hash: ClassHash, - decrease_order_class_hash: ClassHash, - swap_order_class_hash: ClassHash -) -> ContractAddress { - let contract = declare('LiquidationHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'liquidation_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - order_vault_address.into(), - oracle_address.into(), - swap_handler_address.into(), - referral_storage_address.into(), - order_utils_class_hash.into(), - increase_order_class_hash.into(), - decrease_order_class_hash.into(), - swap_order_class_hash.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_swap_handler_address( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('SwapHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'swap_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_referral_storage(event_emitter_address: ContractAddress) -> ContractAddress { - let contract = declare('ReferralStorage'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'referral_storage'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![event_emitter_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_exchange_router( - router_address: ContractAddress, - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_handler_address: ContractAddress, - withdrawal_handler_address: ContractAddress, - order_handler_address: ContractAddress -) -> ContractAddress { - let contract = declare('ExchangeRouter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'exchange_router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - router_address.into(), - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_handler_address.into(), - withdrawal_handler_address.into(), - order_handler_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OrderVault'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - tests_lib::deploy_mock_contract(contract, @constructor_calldata) -} - -fn declare_increase_order() -> ClassHash { - declare('IncreaseOrderUtils').class_hash -} -fn declare_decrease_order() -> ClassHash { - declare('DecreaseOrderUtils').class_hash -} -fn declare_swap_order() -> ClassHash { - declare('SwapOrderUtils').class_hash -} - - -fn declare_order_utils() -> ClassHash { - declare('OrderUtils').class_hash -} - -fn deploy_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let bank_address: ContractAddress = contract_address_const::<'bank'>(); - let contract = declare('Bank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(data_store_address, caller_address); - contract.deploy_at(@constructor_calldata, bank_address).unwrap() -} - -fn deploy_strict_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let strict_bank_address: ContractAddress = contract_address_const::<'strict_bank'>(); - let contract = declare('StrictBank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(strict_bank_address, caller_address); - contract.deploy_at(@constructor_calldata, strict_bank_address).unwrap() -} - -fn deploy_reader() -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let reader_address: ContractAddress = contract_address_const::<'reader'>(); - let contract = declare('Reader'); - let mut constructor_calldata = array![]; - start_prank(reader_address, caller_address); - contract.deploy_at(@constructor_calldata, reader_address).unwrap() -} - -fn deploy_erc20_token(deposit_vault_address: ContractAddress) -> ContractAddress { - let erc20_contract = declare('ERC20'); - let constructor_calldata3 = array![ - 'satoru', 'STU', INITIAL_TOKENS_MINTED, 0, deposit_vault_address.into() - ]; - erc20_contract.deploy(@constructor_calldata3).unwrap() -} diff --git a/tests/integration/test_long_integration.cairo b/tests/integration/test_long_integration.cairo index 28faeb35..cc33b141 100644 --- a/tests/integration/test_long_integration.cairo +++ b/tests/integration/test_long_integration.cairo @@ -64,1037 +64,9 @@ use satoru::market::{market::{UniqueIdMarketImpl},}; use satoru::exchange::order_handler::{ OrderHandler, IOrderHandlerDispatcher, IOrderHandlerDispatcherTrait }; +use satoru::tests_lib::{setup, create_market, teardown}; const INITIAL_TOKENS_MINTED: felt252 = 1000; -// #[test] -// fn test_long_market_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), 500000000000000000 -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), 500000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); - -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token }.mint(market.market_token, 50000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 50000000000); -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000); -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // Create Deposit -// let user1: ContractAddress = contract_address_const::<'user1'>(); -// let user2: ContractAddress = contract_address_const::<'user2'>(); - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: user1, -// callback_contract: user2, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == user1, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000, 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000, 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 1999, max: 2000 }, -// Price { min: 1999, max: 2000 }, -// Price { min: 1999, max: 2000 }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// assert(pool_value_info.pool_value.mag == 200000000000000, 'wrong pool value amount'); -// assert(pool_value_info.long_token_amount == 50000000000, 'wrong long token amount'); -// assert(pool_value_info.short_token_amount == 50000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// // let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; - -// // let balance = market_token_dispatcher.balance_of(user1); - -// let balance_deposit_vault = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// let pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000, max: 5000, }, -// Price { min: 5000, max: 5000, }, -// Price { min: 1, max: 1, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// pool_value_info.pool_value.mag.print(); -// pool_value_info.long_token_amount.print(); -// pool_value_info.short_token_amount.print(); - -// // ************************************* TEST LONG ********************************************* - -// 'begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store.set_u256(max_key_open_interest, 10000000); - -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// // Send token to order_vault in multicall with create_order -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2); - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000, -// initial_collateral_delta_amount: 2, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 10000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 10000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); - -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, -// referal_storage, -// position_key_1, -// market_prices, -// 0, -// contract_address, -// true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// let second_swap_pool_value_info = market_utils::get_pool_value_info( -// data_store, -// market, -// Price { min: 5000, max: 5000, }, -// Price { min: 5000, max: 5000, }, -// Price { min: 1, max: 1, }, -// keys::max_pnl_factor_for_deposits(), -// true, -// ); - -// second_swap_pool_value_info.pool_value.mag.print(); -// second_swap_pool_value_info.long_token_amount.print(); -// second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// //////////////////////////////////// CLOSING POSITION ////////////////////////////////////// -// 'CLOOOOSE POSITION'.print(); - -// let balance_of_mkt_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt before'.print(); -// balance_of_mkt_before.print(); -// oracle.set_primary_prices(market.long_token, 6000); - -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long_dec = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 6000, -// initial_collateral_delta_amount: 1, // 10^18 -// trigger_price: 1, -// acceptable_price: 1, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 6000, -// order_type: OrderType::MarketDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1940); -// 'try to create order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long_dec = order_handler.create_order(caller_address, order_params_long_dec); -// 'long decrease created'.print(); -// let got_order_long_dec = data_store.get_order(key_long_dec); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// let signatures: Span = array![0].span(); -// let set_price_params_dec = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1945); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long_dec, set_price_params_dec, keeper_address); -// 'long pos dec SUCCEEDED'.print(); - -// let first_position_dec = data_store.get_position(position_key_1); - -// 'size tokens before'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd before'.print(); -// first_position.size_in_usd.print(); - -// 'size tokens'.print(); -// first_position_dec.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position_dec.size_in_usd.print(); - -// let balance_of_mkt_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt after'.print(); -// balance_of_mkt_after.print(); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -// #[test] -// fn test_long_demo_market_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), -// 5000000000000000000000000000000000000000000 //500 000 ETH -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), -// 2500000000000000000000000000000000000000000000 //250 000 000 USDC -// ); - -// let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_deposits, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); -// let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); -// oracle.set_primary_prices(market.short_token, 1); - -// 'fill the pool'.print(); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC -// 'filled pool 1'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(caller_address, 9999999999999000000); // 9.999 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(caller_address, 49999999999999999000000); // 49.999 UDC -// 'filled account'.print(); - -// // INITIAL LONG TOKEN IN POOL : 5 ETH -// // INITIAL SHORT TOKEN IN POOL : 25000 USDC - -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); -// let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } -// .balance_of(caller_address); -// let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(caller_address); - -// assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); -// assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); -// assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// 'get balances'.print(); -// // start_prank(market.long_token, caller_address); -// // IERC20Dispatcher { contract_address: market.long_token } -// // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - -// // start_prank(market.short_token, caller_address); -// // IERC20Dispatcher { contract_address: market.short_token } -// // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC -// // 'make transfer'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// // Create Deposit - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: caller_address, -// callback_contract: addresss_zero, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; -// 'create deposit'.print(); - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// 'created deposit'.print(); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000000000000000000000, -// 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000000000000000000000, -// 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// 'execute deposit'.print(); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// 'executed deposit'.print(); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; -// let balance_market_token = market_token_dispatcher.balance_of(caller_address); - -// assert(balance_market_token != 0, 'should receive market token'); - -// let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 -// // pool_value_info.long_token_amount.print(); // 5 000000000000000000 -// // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 - -// // ************************************* TEST LONG ********************************************* - -// 'Begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store -// .set_u256( -// max_key_open_interest, 1000000000000000000000000000000000000000000000000000 -// ); // 1 000 000 - -// // Send token to order_vault in multicall with create_order -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2000000000000000000); // 2ETH - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000000000000000000000, -// initial_collateral_delta_amount: 2000000000000000000, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 50000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 50000000000000000000000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); -// 'OKAAAAAYYYYYY'.print(); -// oracle.set_primary_prices(market.long_token, 6000); -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// // let second_swap_pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // second_swap_pool_value_info.pool_value.mag.print(); -// // second_swap_pool_value_info.long_token_amount.print(); -// // second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// //////////////////////////////////// CLOSING POSITION ////////////////////////////////////// -// 'CLOOOOSE POSITION'.print(); - -// let balance_of_mkt_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt before'.print(); -// balance_of_mkt_before.print(); - -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long_dec = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 6000000000000000000000, // 6000 -// initial_collateral_delta_amount: 1000000000000000000, // 1 ETH 10^18 -// trigger_price: 6000, -// acceptable_price: 6000, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 6000000000000000000000, // 6000 -// order_type: OrderType::MarketDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1940); -// 'try to create order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long_dec = order_handler.create_order(caller_address, order_params_long_dec); -// 'long decrease created'.print(); -// let got_order_long_dec = data_store.get_order(key_long_dec); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// let signatures: Span = array![0].span(); -// let set_price_params_dec = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1945); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long_dec, set_price_params_dec, keeper_address); -// 'long pos dec SUCCEEDED'.print(); - -// let first_position_dec = data_store.get_position(position_key_1); - -// 'size tokens before'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd before'.print(); -// first_position.size_in_usd.print(); - -// 'size tokens'.print(); -// first_position_dec.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position_dec.size_in_usd.print(); - -// let balance_of_mkt_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt after'.print(); -// balance_of_mkt_after.print(); - -// /// close all position -// oracle.set_primary_prices(market.long_token, 7000); - -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long_dec_2 = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 7000000000000000000000, // 6000 -// initial_collateral_delta_amount: 1000000000000000000, // 1 ETH 10^18 -// trigger_price: 7000, -// acceptable_price: 7000, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 7000000000000000000000, // 6000 -// order_type: OrderType::MarketDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1950); -// 'try to create order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long_dec_2 = order_handler.create_order(caller_address, order_params_long_dec_2); -// 'long decrease created'.print(); -// let got_order_long_dec = data_store.get_order(key_long_dec_2); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// let signatures: Span = array![0].span(); -// let set_price_params_dec2 = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1955); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long_dec_2, set_price_params_dec2, keeper_address); -// 'long pos dec SUCCEEDED'.print(); - -// let first_position_dec = data_store.get_position(position_key_1); - -// 'size tokens before 2'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd before 2'.print(); -// first_position.size_in_usd.print(); - -// 'size tokens 2'.print(); -// let token_size_dec = first_position_dec.size_in_tokens; -// assert(token_size_dec == 0, 'wrong token size'); -// 'size in usd 2'.print(); -// first_position_dec.size_in_usd.print(); - -// let balance_of_mkt_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt after 2'.print(); -// balance_of_mkt_after.print(); - -// assert(balance_of_mkt_after == 63000000000000000000000, 'wrong balance final size'); - -// /// ------ TEST SWAP -------- - -// start_prank(contract_address_const::<'ETH'>(), caller_address); //change to switch swap -// // Send token to order_vault in multicall with create_order -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } //change to switch swap -// .transfer(order_vault.contract_address, 1000000000000000000); - -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.long_token, caller_address); //change to switch swap - -// let order_params = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: contract_address, -// initial_collateral_token: market.long_token, //change to switch swap -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 7000000000000000000, -// initial_collateral_delta_amount: 1000000000000000000, // 10^18 -// trigger_price: 0, -// acceptable_price: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketSwap(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: false, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1960); -// //here we create the order but we do not execute it yet -// start_prank(order_handler.contract_address, caller_address); //change to switch swap - -// let key = order_handler.create_order(caller_address, order_params); - -// let got_order = data_store.get_order(key); - -// // data_store -// // .set_u256( -// // keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// // 50000000000000000000000000000 -// // ); -// // data_store -// // .set_u256( -// // keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// // 50000000000000000000000000000 -// // ); - -// // Execute the swap order. -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1965); -// // TODO add real signatures check on Oracle Account -> Later -// order_handler.execute_order_keeper(key, set_price_params, keeper_address); //execute order - -// let balance_of_swap = IERC20Dispatcher { contract_address: contract_address_const::<'USDC'>() } -// .balance_of(caller_address); - -// assert(balance_of_swap == 70000000000000000000000, 'wrong balance final swap'); -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } #[test] fn test_long_increase_decrease_close() { @@ -1185,10 +157,6 @@ fn test_long_increase_decrease_close() { // INITIAL LONG TOKEN IN POOL : 5 ETH // INITIAL SHORT TOKEN IN POOL : 25000 USDC - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } @@ -1201,20 +169,33 @@ fn test_long_increase_decrease_close() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit let addresss_zero: ContractAddress = 0.try_into().unwrap(); @@ -1624,8 +605,8 @@ fn test_long_increase_decrease_close() { assert(balance_USDC_before == 50000000000000000000000, 'balance USDC should be 50000$'); // Balance USDC after = (0.75 ETH * 3850$) + 87.499 (PnL) assert(balance_USDC_after == 52974999999999999998950, 'balance USDC shld be 52974.99$'); - assert(balance_ETH_before == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_after == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_before == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_after == 7000000000000000000, 'balance ETH should be 4'); //////////////////////////////////// CLOSE POSITION ////////////////////////////////////// 'CLOSE POSITION'.print(); @@ -1731,8 +712,8 @@ fn test_long_increase_decrease_close() { assert(balance_USDC_bef_close == 52974999999999999998950, 'balance USDC shld be 52974.99$'); assert(balance_USDC_af_close == 62574999999999999998950, 'balance USDC shld be 62574.99$'); - assert(balance_ETH_af_close == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_bef_close == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_af_close == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_bef_close == 7000000000000000000, 'balance ETH should be 4'); // ********************************************************************************************* // * TEARDOWN * @@ -1829,10 +810,6 @@ fn test_takeprofit_long() { // INITIAL LONG TOKEN IN POOL : 5 ETH // INITIAL SHORT TOKEN IN POOL : 25000 USDC - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } @@ -1845,20 +822,33 @@ fn test_takeprofit_long() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit let addresss_zero: ContractAddress = 0.try_into().unwrap(); @@ -2271,8 +1261,8 @@ fn test_takeprofit_long() { assert(balance_USDC_before == 50000000000000000000000, 'balance USDC should be 50000$'); // Balance USDC after = (0.75 ETH * 3950$) + 162.499 (PnL) assert(balance_USDC_after == 53124999999999999996350, 'balance USDC shld be 53124.99$'); - assert(balance_ETH_before == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_after == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_before == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_after == 7000000000000000000, 'balance ETH should be 4'); //////////////////////////////////// TRIGGER CLOSE POSITION ////////////////////////////////////// 'CLOSE POSITION'.print(); @@ -2378,8 +1368,8 @@ fn test_takeprofit_long() { assert(balance_USDC_bef_close == 53124999999999999996350, 'balance USDC shld be 52974.99$'); assert(balance_USDC_af_close == 62724999999999999996350, 'balance USDC shld be 62724.99$'); - assert(balance_ETH_af_close == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_bef_close == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_af_close == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_bef_close == 7000000000000000000, 'balance ETH should be 4'); // ********************************************************************************************* // * TEARDOWN * @@ -2477,10 +1467,6 @@ fn test_takeprofit_long_increase_fails() { // INITIAL LONG TOKEN IN POOL : 5 ETH // INITIAL SHORT TOKEN IN POOL : 25000 USDC - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } @@ -2493,20 +1479,33 @@ fn test_takeprofit_long_increase_fails() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit let addresss_zero: ContractAddress = 0.try_into().unwrap(); @@ -2919,8 +1918,8 @@ fn test_takeprofit_long_increase_fails() { assert(balance_USDC_before == 50000000000000000000000, 'balance USDC should be 50000$'); // Balance USDC after = (0.75 ETH * 3950$) + 162.499 (PnL) assert(balance_USDC_after == 53124999999999999996350, 'balance USDC shld be 53124.99$'); - assert(balance_ETH_before == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_after == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_before == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_after == 7000000000000000000, 'balance ETH should be 4'); //////////////////////////////////// TRIGGER CLOSE POSITION ////////////////////////////////////// 'CLOSE POSITION'.print(); @@ -3026,8 +2025,8 @@ fn test_takeprofit_long_increase_fails() { assert(balance_USDC_bef_close == 53124999999999999996350, 'balance USDC shld be 52974.99$'); assert(balance_USDC_af_close == 62724999999999999996350, 'balance USDC shld be 62724.99$'); - assert(balance_ETH_af_close == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_bef_close == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_af_close == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_bef_close == 7000000000000000000, 'balance ETH should be 4'); // ********************************************************************************************* // * TEARDOWN * @@ -3125,10 +2124,6 @@ fn test_takeprofit_long_decrease_fails() { // INITIAL LONG TOKEN IN POOL : 5 ETH // INITIAL SHORT TOKEN IN POOL : 25000 USDC - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } @@ -3141,20 +2136,33 @@ fn test_takeprofit_long_decrease_fails() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit let addresss_zero: ContractAddress = 0.try_into().unwrap(); @@ -3567,8 +2575,8 @@ fn test_takeprofit_long_decrease_fails() { assert(balance_USDC_before == 50000000000000000000000, 'balance USDC should be 50000$'); // Balance USDC after = (0.75 ETH * 3950$) + 162.499 (PnL) assert(balance_USDC_after == 53124999999999999996350, 'balance USDC shld be 53124.99$'); - assert(balance_ETH_before == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_after == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_before == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_after == 7000000000000000000, 'balance ETH should be 4'); //////////////////////////////////// TRIGGER CLOSE POSITION ////////////////////////////////////// 'CLOSE POSITION'.print(); @@ -3674,8 +2682,8 @@ fn test_takeprofit_long_decrease_fails() { assert(balance_USDC_bef_close == 53124999999999999996350, 'balance USDC shld be 52974.99$'); assert(balance_USDC_af_close == 62724999999999999996350, 'balance USDC shld be 62724.99$'); - assert(balance_ETH_af_close == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_bef_close == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_af_close == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_bef_close == 7000000000000000000, 'balance ETH should be 4'); // ********************************************************************************************* // * TEARDOWN * @@ -3773,10 +2781,6 @@ fn test_takeprofit_long_close_fails() { // INITIAL LONG TOKEN IN POOL : 5 ETH // INITIAL SHORT TOKEN IN POOL : 25000 USDC - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } @@ -3789,20 +2793,33 @@ fn test_takeprofit_long_close_fails() { assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) - 'get balances'.print(); - // start_prank(market.long_token, caller_address); - // IERC20Dispatcher { contract_address: market.long_token } - // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - - // start_prank(market.short_token, caller_address); - // IERC20Dispatcher { contract_address: market.short_token } - // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC - // 'make transfer'.print(); + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 20 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); + // Create Deposit let addresss_zero: ContractAddress = 0.try_into().unwrap(); @@ -4215,8 +3232,8 @@ fn test_takeprofit_long_close_fails() { assert(balance_USDC_before == 50000000000000000000000, 'balance USDC should be 50000$'); // Balance USDC after = (0.75 ETH * 3950$) + 162.499 (PnL) assert(balance_USDC_after == 53124999999999999996350, 'balance USDC shld be 53124.99$'); - assert(balance_ETH_before == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_after == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_before == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_after == 7000000000000000000, 'balance ETH should be 4'); //////////////////////////////////// TRIGGER CLOSE POSITION ////////////////////////////////////// 'CLOSE POSITION'.print(); @@ -4322,2520 +3339,11 @@ fn test_takeprofit_long_close_fails() { assert(balance_USDC_bef_close == 53124999999999999996350, 'balance USDC shld be 52974.99$'); assert(balance_USDC_af_close == 62724999999999999996350, 'balance USDC shld be 62724.99$'); - assert(balance_ETH_af_close == 4000000000000000000, 'balance ETH should be 4'); - assert(balance_ETH_bef_close == 4000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_af_close == 7000000000000000000, 'balance ETH should be 4'); + assert(balance_ETH_bef_close == 7000000000000000000, 'balance ETH should be 4'); // ********************************************************************************************* // * TEARDOWN * // ********************************************************************************************* teardown(data_store, market_factory); } -// #[test] -// fn test_long_18_close_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), -// 5000000000000000000000000000000000000000000 //500 000 ETH -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), -// 2500000000000000000000000000000000000000000000 //250 000 000 USDC -// ); - -// let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_deposits, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); -// let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); -// oracle.set_primary_prices(market.short_token, 1); - -// 'fill the pool'.print(); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC -// 'filled pool 1'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(caller_address, 9999999999999000000); // 9.999 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(caller_address, 49999999999999999000000); // 49.999 UDC -// 'filled account'.print(); - -// // INITIAL LONG TOKEN IN POOL : 5 ETH -// // INITIAL SHORT TOKEN IN POOL : 25000 USDC - -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); -// let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } -// .balance_of(caller_address); -// let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(caller_address); - -// assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); -// assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); -// assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// 'get balances'.print(); -// // start_prank(market.long_token, caller_address); -// // IERC20Dispatcher { contract_address: market.long_token } -// // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - -// // start_prank(market.short_token, caller_address); -// // IERC20Dispatcher { contract_address: market.short_token } -// // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC -// // 'make transfer'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// // Create Deposit - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: caller_address, -// callback_contract: addresss_zero, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; -// 'create deposit'.print(); - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// 'created deposit'.print(); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000000000000000000000, -// 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000000000000000000000, -// 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// 'execute deposit'.print(); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// 'executed deposit'.print(); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; -// let balance_market_token = market_token_dispatcher.balance_of(caller_address); - -// assert(balance_market_token != 0, 'should receive market token'); - -// let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 -// // pool_value_info.long_token_amount.print(); // 5 000000000000000000 -// // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 - -// // ************************************* TEST LONG ********************************************* - -// 'Begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store -// .set_u256( -// max_key_open_interest, 1000000000000000000000000000000000000000000000000000 -// ); // 1 000 000 - -// // Send token to order_vault in multicall with create_order -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2000000000000000000); // 2ETH - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000000000000000000000, -// initial_collateral_delta_amount: 2000000000000000000, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 50000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 50000000000000000000000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); -// 'OKAAAAAYYYYYY'.print(); -// oracle.set_primary_prices(market.long_token, 6000); -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// // let second_swap_pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // second_swap_pool_value_info.pool_value.mag.print(); -// // second_swap_pool_value_info.long_token_amount.print(); -// // second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// //////////////////////////////////// CLOSING POSITION ////////////////////////////////////// -// 'CLOOOOSE POSITION'.print(); - -// let balance_of_mkt_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt before'.print(); -// balance_of_mkt_before.print(); - -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long_dec = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 12000000000000000000000, // 12000 -// initial_collateral_delta_amount: 2000000000000000000, // 2 ETH 10^18 -// trigger_price: 6000, -// acceptable_price: 6000, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 12000000000000000000000, // 12000 -// order_type: OrderType::MarketDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1940); -// 'try to create order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long_dec = order_handler.create_order(caller_address, order_params_long_dec); -// 'long decrease created'.print(); -// let got_order_long_dec = data_store.get_order(key_long_dec); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// let signatures: Span = array![0].span(); -// let set_price_params_dec = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1945); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long_dec, set_price_params_dec, keeper_address); -// 'long pos dec SUCCEEDED'.print(); - -// let first_position_dec = data_store.get_position(position_key_1); - -// 'size tokens before'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd before'.print(); -// first_position.size_in_usd.print(); - -// 'size tokens'.print(); -// first_position_dec.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position_dec.size_in_usd.print(); - -// let balance_of_mkt_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt after'.print(); -// balance_of_mkt_after.print(); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -// #[test] -// fn test_long_18_takeprofit_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), -// 5000000000000000000000000000000000000000000 //500 000 ETH -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), -// 2500000000000000000000000000000000000000000000 //250 000 000 USDC -// ); - -// let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_deposits, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); -// let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); -// oracle.set_primary_prices(market.short_token, 1); - -// 'fill the pool'.print(); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC -// 'filled pool 1'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(caller_address, 9999999999999000000); // 9.999 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(caller_address, 49999999999999999000000); // 49.999 UDC -// 'filled account'.print(); - -// // INITIAL LONG TOKEN IN POOL : 5 ETH -// // INITIAL SHORT TOKEN IN POOL : 25000 USDC - -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); -// let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } -// .balance_of(caller_address); -// let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(caller_address); - -// assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); -// assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); -// assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// 'get balances'.print(); -// // start_prank(market.long_token, caller_address); -// // IERC20Dispatcher { contract_address: market.long_token } -// // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - -// // start_prank(market.short_token, caller_address); -// // IERC20Dispatcher { contract_address: market.short_token } -// // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC -// // 'make transfer'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// // Create Deposit - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: caller_address, -// callback_contract: addresss_zero, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; -// 'create deposit'.print(); - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// 'created deposit'.print(); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000000000000000000000, -// 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000000000000000000000, -// 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// 'execute deposit'.print(); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// 'executed deposit'.print(); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; -// let balance_market_token = market_token_dispatcher.balance_of(caller_address); - -// assert(balance_market_token != 0, 'should receive market token'); - -// let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 -// // pool_value_info.long_token_amount.print(); // 5 000000000000000000 -// // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 - -// // ************************************* TEST LONG ********************************************* - -// 'Begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store -// .set_u256( -// max_key_open_interest, 1000000000000000000000000000000000000000000000000000 -// ); // 1 000 000 - -// // Send token to order_vault in multicall with create_order -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2000000000000000000); // 2ETH - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000000000000000000000, -// initial_collateral_delta_amount: 2000000000000000000, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 50000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 50000000000000000000000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); -// 'OKAAAAAYYYYYY'.print(); -// oracle.set_primary_prices(market.long_token, 6000); -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// // let second_swap_pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // second_swap_pool_value_info.pool_value.mag.print(); -// // second_swap_pool_value_info.long_token_amount.print(); -// // second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// //////////////////////////////////// TAKE PROFIT TRIGGER ///////////////////////////////// - -// 'Take profit start'.print(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_tp = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 7000000000000000000000, // 12000 -// initial_collateral_delta_amount: 1000000000000000000, // 2 ETH 10^18 -// trigger_price: 7000, -// acceptable_price: 7000, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 7000000000000000000000, // 12000 -// order_type: OrderType::LimitDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1940); -// 'create takeprofit order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_tp = order_handler.create_order(caller_address, order_params_tp); -// 'takeprofit created'.print(); -// let got_order_tp = data_store.get_order(key_tp); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// 'takeproit passed'.print(); -// let signatures: Span = array![0].span(); -// let set_price_params_dec = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1945); -// // TODO add real signatures check on Oracle Account -// oracle.set_primary_prices(market.long_token, 7000); -// order_handler.execute_order_keeper(key_tp, set_price_params_dec, keeper_address); -// 'take profit pos dec SUCCEEDED'.print(); - -// //////////////////////////////////// CLOSING POSITION ////////////////////////////////////// -// 'CLOOOOSE POSITION'.print(); - -// let balance_of_mkt_before = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt before'.print(); -// balance_of_mkt_before.print(); - -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long_dec = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![market.market_token]), -// size_delta_usd: 6000000000000000000000, // 12000 -// initial_collateral_delta_amount: 1000000000000000000, // 2 ETH 10^18 -// trigger_price: 6000, -// acceptable_price: 6000, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 6000000000000000000000, // 12000 -// order_type: OrderType::MarketDecrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the long order. -// start_roll(order_handler.contract_address, 1940); -// 'try to create order'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long_dec = order_handler.create_order(caller_address, order_params_long_dec); -// 'long decrease created'.print(); -// let got_order_long_dec = data_store.get_order(key_long_dec); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// let signatures: Span = array![0].span(); -// let set_price_params_dec = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1945); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long_dec, set_price_params_dec, keeper_address); -// 'long pos dec SUCCEEDED'.print(); - -// let first_position_dec = data_store.get_position(position_key_1); - -// 'size tokens before'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd before'.print(); -// first_position.size_in_usd.print(); - -// 'size tokens'.print(); -// first_position_dec.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position_dec.size_in_usd.print(); - -// let balance_of_mkt_after = IERC20Dispatcher { -// contract_address: contract_address_const::<'USDC'>() -// } -// .balance_of(caller_address); -// 'balance of mkt after'.print(); -// balance_of_mkt_after.print(); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -// #[test] -// fn test_long_liquidable_market_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// liquidation_handler, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), -// 5000000000000000000000000000000000000000000 //500 000 ETH -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), -// 2500000000000000000000000000000000000000000000 //250 000 000 USDC -// ); - -// let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_deposits, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); -// let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); -// oracle.set_primary_prices(market.short_token, 1); - -// 'fill the pool'.print(); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC -// 'filled pool 1'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(caller_address, 9999999999999000000); // 9.999 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(caller_address, 49999999999999999000000); // 49.999 UDC -// 'filled account'.print(); - -// // INITIAL LONG TOKEN IN POOL : 5 ETH -// // INITIAL SHORT TOKEN IN POOL : 25000 USDC - -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); -// let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } -// .balance_of(caller_address); -// let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(caller_address); - -// assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); -// assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); -// assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// 'get balances'.print(); -// // start_prank(market.long_token, caller_address); -// // IERC20Dispatcher { contract_address: market.long_token } -// // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - -// // start_prank(market.short_token, caller_address); -// // IERC20Dispatcher { contract_address: market.short_token } -// // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC -// // 'make transfer'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// // Create Deposit - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: caller_address, -// callback_contract: addresss_zero, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; -// 'create deposit'.print(); - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// 'created deposit'.print(); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000000000000000000000, -// 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000000000000000000000, -// 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// 'execute deposit'.print(); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// 'executed deposit'.print(); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; -// let balance_market_token = market_token_dispatcher.balance_of(caller_address); - -// assert(balance_market_token != 0, 'should receive market token'); - -// let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 -// // pool_value_info.long_token_amount.print(); // 5 000000000000000000 -// // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 - -// // ************************************* TEST LONG ********************************************* - -// 'Begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store -// .set_u256( -// max_key_open_interest, 1000000000000000000000000000000000000000000000000000 -// ); // 1 000 000 - -// // Send token to order_vault in multicall with create_order -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2000000000000000000); // 2ETH - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000000000000000000000, -// initial_collateral_delta_amount: 2000000000000000000, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 50000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 50000000000000000000000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); -// 'OKAAAAAYYYYYY'.print(); -// oracle.set_primary_prices(market.long_token, 6000); -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// // let second_swap_pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // second_swap_pool_value_info.pool_value.mag.print(); -// // second_swap_pool_value_info.long_token_amount.print(); -// // second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// // ------------------------Check Liquidation--------------------------- -// let market_prices_liquidation = market_utils::MarketPrices { -// index_token_price: Price { min: 4000, max: 4000, }, -// long_token_price: Price { min: 4000, max: 4000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; - -// let (is_liquid, why_liquid) = position_utils::is_position_liquiditable( -// data_store, referal_storage, first_position, market, market_prices_liquidation, false -// ); - -// assert(is_liquid == false, 'position not liquid'); - -// let market_prices_liquidation = market_utils::MarketPrices { -// index_token_price: Price { min: 2500, max: 2500, }, -// long_token_price: Price { min: 2500, max: 2500, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; - -// let (is_liquid, why_liquid) = position_utils::is_position_liquiditable( -// data_store, referal_storage, first_position, market, market_prices_liquidation, false -// ); - -// assert(is_liquid == true, 'position liquidable'); -// oracle.set_primary_prices(market.long_token, 2500); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); -// role_store.grant_role(keeper_address, role::LIQUIDATION_KEEPER); - -// start_prank(liquidation_handler.contract_address, keeper_address); -// start_roll(liquidation_handler.contract_address, 1940); - -// liquidation_handler -// .execute_liquidation( -// caller_address, market.market_token, market.long_token, true, set_price_params -// ); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -// #[test] -// #[should_panic(expected: ('position not be liquidated',))] -// fn test_long_liquidable_fails_integration() { -// // ********************************************************************************************* -// // * SETUP * -// // ********************************************************************************************* -// let ( -// caller_address, -// market_factory_address, -// role_store_address, -// data_store_address, -// market_token_class_hash, -// market_factory, -// role_store, -// data_store, -// event_emitter, -// exchange_router, -// deposit_handler, -// deposit_vault, -// oracle, -// order_handler, -// order_vault, -// reader, -// referal_storage, -// withdrawal_handler, -// withdrawal_vault, -// liquidation_handler, -// ) = -// setup(); - -// // ********************************************************************************************* -// // * TEST LOGIC * -// // ********************************************************************************************* - -// // Create a market. -// let market = data_store.get_market(create_market(market_factory)); - -// // Set params in data_store -// data_store.set_address(keys::fee_token(), market.index_token); -// data_store.set_u256(keys::max_swap_path_length(), 5); - -// // Set max pool amount. -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.long_token), -// 5000000000000000000000000000000000000000000 //500 000 ETH -// ); -// data_store -// .set_u256( -// keys::max_pool_amount_key(market.market_token, market.short_token), -// 2500000000000000000000000000000000000000000000 //250 000 000 USDC -// ); - -// let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_deposits, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); -// let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); -// data_store -// .set_u256( -// keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, true), -// 50000000000000000000000000000000000000000000000 -// ); - -// oracle.set_primary_prices(market.long_token, 5000); -// oracle.set_primary_prices(market.short_token, 1); - -// 'fill the pool'.print(); -// // Fill the pool. -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC -// 'filled pool 1'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(caller_address, 9999999999999000000); // 9.999 ETH -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(caller_address, 49999999999999999000000); // 49.999 UDC -// 'filled account'.print(); - -// // INITIAL LONG TOKEN IN POOL : 5 ETH -// // INITIAL SHORT TOKEN IN POOL : 25000 USDC - -// // TODO Check why we don't need to set pool_amount_key -// // // Set pool amount in data_store. -// // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); - -// let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); -// let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } -// .balance_of(caller_address); -// let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(caller_address); - -// assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); -// assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); -// assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - -// // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) -// 'get balances'.print(); -// // start_prank(market.long_token, caller_address); -// // IERC20Dispatcher { contract_address: market.long_token } -// // .transfer(deposit_vault.contract_address, 5000000000000000000); // 5 ETH - -// // start_prank(market.short_token, caller_address); -// // IERC20Dispatcher { contract_address: market.short_token } -// // .transfer(deposit_vault.contract_address, 25000000000000000000000); // 25000 USDC -// // 'make transfer'.print(); - -// IERC20Dispatcher { contract_address: market.long_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// IERC20Dispatcher { contract_address: market.short_token } -// .mint(deposit_vault.contract_address, 50000000000000000000000000000); // 50 000 000 000 -// // Create Deposit - -// let addresss_zero: ContractAddress = 0.try_into().unwrap(); - -// let params = CreateDepositParams { -// receiver: caller_address, -// callback_contract: addresss_zero, -// ui_fee_receiver: addresss_zero, -// market: market.market_token, -// initial_long_token: market.long_token, -// initial_short_token: market.short_token, -// long_token_swap_path: Array32Trait::::span32(@array![]), -// short_token_swap_path: Array32Trait::::span32(@array![]), -// min_market_tokens: 0, -// execution_fee: 0, -// callback_gas_limit: 0, -// }; -// 'create deposit'.print(); - -// start_roll(deposit_handler.contract_address, 1910); -// let key = deposit_handler.create_deposit(caller_address, params); -// let first_deposit = data_store.get_deposit(key); - -// 'created deposit'.print(); - -// assert(first_deposit.account == caller_address, 'Wrong account depositer'); -// assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); -// assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); -// assert( -// first_deposit.initial_long_token_amount == 50000000000000000000000000000, -// 'Wrong initial long token amount' -// ); -// assert( -// first_deposit.initial_short_token_amount == 50000000000000000000000000000, -// 'Wrong init short token amount' -// ); - -// let price_params = SetPricesParams { // TODO -// signer_info: 1, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1900, 1900], -// compacted_max_oracle_block_numbers: array![1910, 1910], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![18, 18], -// compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// start_prank(role_store.contract_address, caller_address); - -// role_store.grant_role(caller_address, role::ORDER_KEEPER); -// role_store.grant_role(caller_address, role::ROLE_ADMIN); -// role_store.grant_role(caller_address, role::CONTROLLER); -// role_store.grant_role(caller_address, role::MARKET_KEEPER); - -// 'execute deposit'.print(); - -// // Execute Deposit -// start_roll(deposit_handler.contract_address, 1915); -// deposit_handler.execute_deposit(key, price_params); - -// 'executed deposit'.print(); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // Price { min: 2000, max: 2000 }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // assert(pool_value_info.pool_value.mag == 42000000000000000000000, 'wrong pool value amount'); -// // assert(pool_value_info.long_token_amount == 6000000000000000000, 'wrong long token amount'); -// // assert(pool_value_info.short_token_amount == 30000000000000000000000, 'wrong short token amount'); - -// let not_deposit = data_store.get_deposit(key); -// let default_deposit: Deposit = Default::default(); -// assert(not_deposit == default_deposit, 'Still existing deposit'); - -// let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; -// let balance_market_token = market_token_dispatcher.balance_of(caller_address); - -// assert(balance_market_token != 0, 'should receive market token'); - -// let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } -// .balance_of(deposit_vault.contract_address); - -// // let pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 -// // pool_value_info.long_token_amount.print(); // 5 000000000000000000 -// // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 - -// // ************************************* TEST LONG ********************************************* - -// 'Begining of LONG TEST'.print(); - -// let key_open_interest = keys::open_interest_key( -// market.market_token, contract_address_const::<'ETH'>(), true -// ); -// data_store.set_u256(key_open_interest, 1); -// let max_key_open_interest = keys::max_open_interest_key(market.market_token, true); -// data_store -// .set_u256( -// max_key_open_interest, 1000000000000000000000000000000000000000000000000000 -// ); // 1 000 000 - -// // Send token to order_vault in multicall with create_order -// start_prank(contract_address_const::<'ETH'>(), caller_address); -// IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } -// .transfer(order_vault.contract_address, 2000000000000000000); // 2ETH - -// 'transfer made'.print(); -// // Create order_params Struct -// let contract_address = contract_address_const::<0>(); -// start_prank(market.market_token, caller_address); -// start_prank(market.long_token, caller_address); -// let order_params_long = CreateOrderParams { -// receiver: caller_address, -// callback_contract: contract_address, -// ui_fee_receiver: contract_address, -// market: market.market_token, -// initial_collateral_token: market.long_token, -// swap_path: Array32Trait::::span32(@array![]), -// size_delta_usd: 10000000000000000000000, -// initial_collateral_delta_amount: 2000000000000000000, // 10^18 -// trigger_price: 5000, -// acceptable_price: 5500, -// execution_fee: 0, -// callback_gas_limit: 0, -// min_output_amount: 0, -// order_type: OrderType::MarketIncrease(()), -// decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), -// is_long: true, -// referral_code: 0 -// }; -// // Create the swap order. -// start_roll(order_handler.contract_address, 1930); -// 'try to create prder'.print(); -// start_prank(order_handler.contract_address, caller_address); -// let key_long = order_handler.create_order(caller_address, order_params_long); -// 'long created'.print(); -// let got_order_long = data_store.get_order(key_long); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); -// // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); -// // Execute the swap order. - -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), -// 50000000000000000000000000000 -// ); -// data_store -// .set_u256( -// keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), -// 50000000000000000000000000000 -// ); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); - -// stop_prank(order_handler.contract_address); -// start_prank(order_handler.contract_address, keeper_address); -// start_roll(order_handler.contract_address, 1935); -// // TODO add real signatures check on Oracle Account -// order_handler.execute_order_keeper(key_long, set_price_params, keeper_address); -// 'long position SUCCEEDED'.print(); -// let position_key = data_store.get_account_position_keys(caller_address, 0, 10); - -// let position_key_1: felt252 = *position_key.at(0); -// let first_position = data_store.get_position(position_key_1); -// let market_prices = market_utils::MarketPrices { -// index_token_price: Price { min: 8000, max: 8000, }, -// long_token_price: Price { min: 8000, max: 8000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; -// 'size tokens'.print(); -// first_position.size_in_tokens.print(); -// 'size in usd'.print(); -// first_position.size_in_usd.print(); -// 'OKAAAAAYYYYYY'.print(); -// oracle.set_primary_prices(market.long_token, 6000); -// let first_position_after_pump = data_store.get_position(position_key_1); -// 'size tokens after pump'.print(); -// first_position_after_pump.size_in_tokens.print(); -// 'size in usd after pump'.print(); -// first_position_after_pump.size_in_usd.print(); - -// let position_info = reader -// .get_position_info( -// data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true -// ); -// 'pnl'.print(); -// position_info.base_pnl_usd.mag.print(); - -// // let second_swap_pool_value_info = market_utils::get_pool_value_info( -// // data_store, -// // market, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 5000, max: 5000, }, -// // Price { min: 1, max: 1, }, -// // keys::max_pnl_factor_for_deposits(), -// // true, -// // ); - -// // second_swap_pool_value_info.pool_value.mag.print(); -// // second_swap_pool_value_info.long_token_amount.print(); -// // second_swap_pool_value_info.short_token_amount.print(); -// // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = -// // position_utils::get_position_pnl_usd( -// // data_store, market, market_prices, first_position, 5000 -// // ); -// // position_pnl_usd.mag.print(); - -// // ------------------------Check Liquidation--------------------------- -// let market_prices_liquidation = market_utils::MarketPrices { -// index_token_price: Price { min: 4000, max: 4000, }, -// long_token_price: Price { min: 4000, max: 4000, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; - -// let (is_liquid, why_liquid) = position_utils::is_position_liquiditable( -// data_store, referal_storage, first_position, market, market_prices_liquidation, false -// ); - -// assert(is_liquid == false, 'position not liquid'); - -// let market_prices_liquidation = market_utils::MarketPrices { -// index_token_price: Price { min: 2500, max: 2500, }, -// long_token_price: Price { min: 2500, max: 2500, }, -// short_token_price: Price { min: 1, max: 1, }, -// }; - -// let (is_liquid, why_liquid) = position_utils::is_position_liquiditable( -// data_store, referal_storage, first_position, market, market_prices_liquidation, false -// ); - -// assert(is_liquid == true, 'position liquidable'); - -// let signatures: Span = array![0].span(); -// let set_price_params = SetPricesParams { -// signer_info: 2, -// tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], -// compacted_min_oracle_block_numbers: array![1910, 1910], -// compacted_max_oracle_block_numbers: array![1920, 1920], -// compacted_oracle_timestamps: array![9999, 9999], -// compacted_decimals: array![1, 1], -// compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_min_prices_indexes: array![0], -// compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted -// compacted_max_prices_indexes: array![0], -// signatures: array![ -// array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() -// ], -// price_feed_tokens: array![] -// }; - -// let keeper_address = contract_address_const::<'keeper'>(); -// role_store.grant_role(keeper_address, role::ORDER_KEEPER); -// role_store.grant_role(keeper_address, role::LIQUIDATION_KEEPER); - -// start_prank(liquidation_handler.contract_address, keeper_address); -// start_roll(liquidation_handler.contract_address, 1940); - -// liquidation_handler -// .execute_liquidation( -// caller_address, market.market_token, market.long_token, true, set_price_params -// ); - -// // ********************************************************************************************* -// // * TEARDOWN * -// // ********************************************************************************************* -// teardown(data_store, market_factory); -// } - -fn create_market(market_factory: IMarketFactoryDispatcher) -> ContractAddress { - // Create a market. - let (index_token, short_token) = deploy_tokens(); - let market_type = 'market_type'; - - // Index token is the same as long token here. - market_factory.create_market(index_token, index_token, short_token, market_type) -} - -/// Utility functions to deploy tokens for a market. -fn deploy_tokens() -> (ContractAddress, ContractAddress) { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let contract = declare('ERC20'); - - let eth_address = contract_address_const::<'ETH'>(); - let constructor_calldata = array!['Ethereum', 'ETH', 1000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, eth_address).unwrap(); - - let usdc_address = contract_address_const::<'USDC'>(); - let constructor_calldata = array!['usdc', 'USDC', 1000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, usdc_address).unwrap(); - (eth_address, usdc_address) -} - -/// Utility function to setup the test environment. -fn setup() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, - ILiquidationHandlerDispatcher, -) { - let ( - caller_address, - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) = - setup_contracts(); - grant_roles_and_prank(caller_address, role_store, data_store, market_factory); - ( - caller_address, - market_factory.contract_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) -} - -// Utility function to grant roles and prank the caller address. -/// Grants roles and pranks the caller address. -/// -/// # Arguments -/// -/// * `caller_address` - The address of the caller. -/// * `role_store` - The interface to interact with the `RoleStore` contract. -/// * `data_store` - The interface to interact with the `DataStore` contract. -/// * `market_factory` - The interface to interact with the `MarketFactory` contract. -fn grant_roles_and_prank( - caller_address: ContractAddress, - role_store: IRoleStoreDispatcher, - data_store: IDataStoreDispatcher, - market_factory: IMarketFactoryDispatcher, -) { - start_prank(role_store.contract_address, caller_address); - - // Grant the caller the `CONTROLLER` role. - role_store.grant_role(caller_address, role::CONTROLLER); - - // Grant the call the `MARKET_KEEPER` role. - // This role is required to create a market. - role_store.grant_role(caller_address, role::MARKET_KEEPER); - - // Prank the caller address for calls to `DataStore` contract. - // We need this so that the caller has the CONTROLLER role. - start_prank(data_store.contract_address, caller_address); - - // Start pranking the `MarketFactory` contract. This is necessary to mock the behavior of the contract - // for testing purposes. - start_prank(market_factory.contract_address, caller_address); -} - -/// Utility function to teardown the test environment. -fn teardown(data_store: IDataStoreDispatcher, market_factory: IMarketFactoryDispatcher) { - stop_prank(data_store.contract_address); - stop_prank(market_factory.contract_address); -} - -/// Setup required contracts. -fn setup_contracts() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, - ILiquidationHandlerDispatcher, -) { - // Deploy the role store contract. - let role_store_address = deploy_role_store(); - - // Create a role store dispatcher. - let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; - - // Deploy the contract. - let data_store_address = deploy_data_store(role_store_address); - // Create a safe dispatcher to interact with the contract. - let data_store = IDataStoreDispatcher { contract_address: data_store_address }; - - // Declare the `MarketToken` contract. - let market_token_class_hash = declare_market_token(); - - // Deploy the event emitter contract. - let event_emitter_address = deploy_event_emitter(); - // Create a safe dispatcher to interact with the contract. - let event_emitter = IEventEmitterDispatcher { contract_address: event_emitter_address }; - - // Deploy the router contract. - let router_address = deploy_router(role_store_address); - - // Deploy the market factory. - let market_factory_address = deploy_market_factory( - data_store_address, role_store_address, event_emitter_address, market_token_class_hash - ); - // Create a safe dispatcher to interact with the contract. - let market_factory = IMarketFactoryDispatcher { contract_address: market_factory_address }; - - let oracle_store_address = deploy_oracle_store(role_store_address, event_emitter_address); - let oracle_address = deploy_oracle( - role_store_address, oracle_store_address, contract_address_const::<'pragma'>() - ); - - let oracle = IOracleDispatcher { contract_address: oracle_address }; - - let deposit_vault_address = deploy_deposit_vault(role_store_address, data_store_address); - - let deposit_vault = IDepositVaultDispatcher { contract_address: deposit_vault_address }; - let deposit_handler_address = deploy_deposit_handler( - data_store_address, - role_store_address, - event_emitter_address, - deposit_vault_address, - oracle_address - ); - let deposit_handler = IDepositHandlerDispatcher { contract_address: deposit_handler_address }; - - let withdrawal_vault_address = deploy_withdrawal_vault(data_store_address, role_store_address); - let withdrawal_handler_address = deploy_withdrawal_handler( - data_store_address, - role_store_address, - event_emitter_address, - withdrawal_vault_address, - oracle_address - ); - - let order_vault_address = deploy_order_vault( - data_store.contract_address, role_store.contract_address - ); - let order_vault = IOrderVaultDispatcher { contract_address: order_vault_address }; - - let swap_handler_address = deploy_swap_handler_address(role_store_address, data_store_address); - let referral_storage_address = deploy_referral_storage(event_emitter_address); - let increase_order_class_hash = declare_increase_order(); - let decrease_order_class_hash = declare_decrease_order(); - let swap_order_class_hash = declare_swap_order(); - - let order_utils_class_hash = declare_order_utils(); - - let order_handler_address = deploy_order_handler( - data_store_address, - role_store_address, - event_emitter_address, - order_vault_address, - oracle_address, - swap_handler_address, - referral_storage_address, - order_utils_class_hash, - increase_order_class_hash, - decrease_order_class_hash, - swap_order_class_hash - ); - let order_handler = IOrderHandlerDispatcher { contract_address: order_handler_address }; - - let exchange_router_address = deploy_exchange_router( - router_address, - data_store_address, - role_store_address, - event_emitter_address, - deposit_handler_address, - withdrawal_handler_address, - order_handler_address - ); - let exchange_router = IExchangeRouterDispatcher { contract_address: exchange_router_address }; - - let bank_address = deploy_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the Bank contract. - let bank = IBankDispatcher { contract_address: bank_address }; - - // Deploy the strict bank contract - let strict_bank_address = deploy_strict_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the StrictBank contract. - let strict_bank = IStrictBankDispatcher { contract_address: strict_bank_address }; - - let reader_address = deploy_reader(); - let reader = IReaderDispatcher { contract_address: reader_address }; - - let referal_storage = IReferralStorageDispatcher { contract_address: referral_storage_address }; - - let withdrawal_handler = IWithdrawalHandlerDispatcher { - contract_address: withdrawal_handler_address - }; - let withdrawal_vault = IWithdrawalVaultDispatcher { - contract_address: withdrawal_vault_address - }; - let liquidation_handler_address = deploy_liquidation_handler( - data_store_address, - role_store_address, - event_emitter_address, - order_vault_address, - oracle_address, - swap_handler_address, - referral_storage_address, - order_utils_class_hash, - increase_order_class_hash, - decrease_order_class_hash, - swap_order_class_hash - ); - - let liquidation_handler = ILiquidationHandlerDispatcher { - contract_address: liquidation_handler_address - }; - ( - contract_address_const::<'caller'>(), - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - liquidation_handler, - ) -} - -/// Utility function to declare a `MarketToken` contract. -fn declare_market_token() -> ContractClass { - declare('MarketToken') -} - -/// Utility function to deploy a market factory contract and return its address. -fn deploy_market_factory( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - market_token_class_hash: ContractClass, -) -> ContractAddress { - let contract = declare('MarketFactory'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'market_factory'>(); - start_prank(deployed_contract_address, caller_address); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - constructor_calldata.append(event_emitter_address.into()); - constructor_calldata.append(market_token_class_hash.class_hash.into()); - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - - -fn deploy_data_store(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('DataStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address: ContractAddress = 0x1.try_into().unwrap(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_role_store() -> ContractAddress { - let contract = declare('RoleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'role_store'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![caller_address.into()], deployed_contract_address).unwrap() -} - -fn deploy_event_emitter() -> ContractAddress { - let contract = declare('EventEmitter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'event_emitter'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![], deployed_contract_address).unwrap() -} - -fn deploy_router(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('Router'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_deposit_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_handler'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_vault_address.into(), - oracle_address.into() - ], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle_store( - role_store_address: ContractAddress, event_emitter_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OracleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle_store'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), event_emitter_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle( - role_store_address: ContractAddress, - oracle_store_address: ContractAddress, - pragma_address: ContractAddress -) -> ContractAddress { - let contract = declare('Oracle'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), oracle_store_address.into(), pragma_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_deposit_vault( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_vault'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![data_store_address.into(), role_store_address.into()], deployed_contract_address - ) - .unwrap() -} - -fn deploy_withdrawal_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - withdrawal_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - withdrawal_vault_address.into(), - oracle_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_withdrawal_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_vault'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![data_store_address.into(), role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - order_vault_address: ContractAddress, - oracle_address: ContractAddress, - swap_handler_address: ContractAddress, - referral_storage_address: ContractAddress, - order_utils_class_hash: ClassHash, - increase_order_class_hash: ClassHash, - decrease_order_class_hash: ClassHash, - swap_order_class_hash: ClassHash -) -> ContractAddress { - let contract = declare('OrderHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'order_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - order_vault_address.into(), - oracle_address.into(), - swap_handler_address.into(), - referral_storage_address.into(), - order_utils_class_hash.into(), - increase_order_class_hash.into(), - decrease_order_class_hash.into(), - swap_order_class_hash.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_liquidation_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - order_vault_address: ContractAddress, - oracle_address: ContractAddress, - swap_handler_address: ContractAddress, - referral_storage_address: ContractAddress, - order_utils_class_hash: ClassHash, - increase_order_class_hash: ClassHash, - decrease_order_class_hash: ClassHash, - swap_order_class_hash: ClassHash -) -> ContractAddress { - let contract = declare('LiquidationHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'liquidation_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - order_vault_address.into(), - oracle_address.into(), - swap_handler_address.into(), - referral_storage_address.into(), - order_utils_class_hash.into(), - increase_order_class_hash.into(), - decrease_order_class_hash.into(), - swap_order_class_hash.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_swap_handler_address( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('SwapHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'swap_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_referral_storage(event_emitter_address: ContractAddress) -> ContractAddress { - let contract = declare('ReferralStorage'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'referral_storage'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![event_emitter_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_exchange_router( - router_address: ContractAddress, - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_handler_address: ContractAddress, - withdrawal_handler_address: ContractAddress, - order_handler_address: ContractAddress -) -> ContractAddress { - let contract = declare('ExchangeRouter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'exchange_router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - router_address.into(), - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_handler_address.into(), - withdrawal_handler_address.into(), - order_handler_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OrderVault'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - tests_lib::deploy_mock_contract(contract, @constructor_calldata) -} - -fn declare_increase_order() -> ClassHash { - declare('IncreaseOrderUtils').class_hash -} -fn declare_decrease_order() -> ClassHash { - declare('DecreaseOrderUtils').class_hash -} -fn declare_swap_order() -> ClassHash { - declare('SwapOrderUtils').class_hash -} - - -fn declare_order_utils() -> ClassHash { - declare('OrderUtils').class_hash -} - -fn deploy_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let bank_address: ContractAddress = contract_address_const::<'bank'>(); - let contract = declare('Bank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(data_store_address, caller_address); - contract.deploy_at(@constructor_calldata, bank_address).unwrap() -} - -fn deploy_strict_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let strict_bank_address: ContractAddress = contract_address_const::<'strict_bank'>(); - let contract = declare('StrictBank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(strict_bank_address, caller_address); - contract.deploy_at(@constructor_calldata, strict_bank_address).unwrap() -} - -fn deploy_reader() -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let reader_address: ContractAddress = contract_address_const::<'reader'>(); - let contract = declare('Reader'); - let mut constructor_calldata = array![]; - start_prank(reader_address, caller_address); - contract.deploy_at(@constructor_calldata, reader_address).unwrap() -} - -fn deploy_erc20_token(deposit_vault_address: ContractAddress) -> ContractAddress { - let erc20_contract = declare('ERC20'); - let constructor_calldata3 = array![ - 'satoru', 'STU', INITIAL_TOKENS_MINTED, 0, deposit_vault_address.into() - ]; - erc20_contract.deploy(@constructor_calldata3).unwrap() -} diff --git a/tests/integration/test_short_integration.cairo b/tests/integration/test_short_integration.cairo index 991f7857..0b4348eb 100644 --- a/tests/integration/test_short_integration.cairo +++ b/tests/integration/test_short_integration.cairo @@ -52,6 +52,9 @@ use satoru::price::price::{Price, PriceTrait}; use satoru::position::position_utils; use satoru::withdrawal::withdrawal_utils; +use satoru::exchange::liquidation_handler::{ + ILiquidationHandlerDispatcher, ILiquidationHandlerDispatcherTrait +}; use satoru::order::order::{Order, OrderType, SecondaryOrderType, DecreasePositionSwapType}; use satoru::order::order_vault::{IOrderVaultDispatcher, IOrderVaultDispatcherTrait}; use satoru::order::base_order_utils::{CreateOrderParams}; @@ -61,11 +64,11 @@ use satoru::market::{market::{UniqueIdMarketImpl},}; use satoru::exchange::order_handler::{ OrderHandler, IOrderHandlerDispatcher, IOrderHandlerDispatcherTrait }; +use satoru::tests_lib::{setup, create_market, teardown}; const INITIAL_TOKENS_MINTED: felt252 = 1000; - #[test] -fn test_short_market_integration() { +fn test_short_increase_decrease_close() { // ********************************************************************************************* // * SETUP * // ********************************************************************************************* @@ -89,6 +92,7 @@ fn test_short_market_integration() { referal_storage, withdrawal_handler, withdrawal_vault, + liquidation_handler, ) = setup(); @@ -106,42 +110,98 @@ fn test_short_market_integration() { // Set max pool amount. data_store .set_u256( - keys::max_pool_amount_key(market.market_token, market.long_token), 500000000000000000 + keys::max_pool_amount_key(market.market_token, market.long_token), + 5000000000000000000000000000000000000000000 //500 000 ETH ); data_store .set_u256( - keys::max_pool_amount_key(market.market_token, market.short_token), 500000000000000000 + keys::max_pool_amount_key(market.market_token, market.short_token), + 2500000000000000000000000000000000000000000000 //250 000 000 USDC ); - oracle.set_primary_prices(market.long_token, 5000); - oracle.set_primary_prices(market.short_token, 1); + let factor_for_deposits: felt252 = keys::max_pnl_factor_for_deposits(); + data_store + .set_u256( + keys::max_pnl_factor_key(factor_for_deposits, market.market_token, false), + 50000000000000000000000000000000000000000000000 + ); + let factor_for_withdrawal: felt252 = keys::max_pnl_factor_for_withdrawals(); + data_store + .set_u256( + keys::max_pnl_factor_key(factor_for_withdrawal, market.market_token, false), + 50000000000000000000000000000000000000000000000 + ); + data_store.set_u256(keys::reserve_factor_key(market.market_token, false), 1000000000000000000); + data_store + .set_u256( + keys::open_interest_reserve_factor_key(market.market_token, false), 1000000000000000000 + ); + data_store.set_bool('REENTRANCY_GUARD_STATUS', false); + + 'fill the pool'.print(); // Fill the pool. - IERC20Dispatcher { contract_address: market.long_token }.mint(market.market_token, 50000000000); + IERC20Dispatcher { contract_address: market.long_token } + .mint(market.market_token, 50000000000000000000000000000000000000); // 5 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(market.market_token, 50000000000); - // TODO Check why we don't need to set pool_amount_key - // // Set pool amount in data_store. - // let mut key = keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()); + .mint(market.market_token, 25000000000000000000000000000000000000000); // 25000 USDC + 'filled pool 1'.print(); - // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) IERC20Dispatcher { contract_address: market.long_token } - .mint(deposit_vault.contract_address, 50000000000); + .mint(caller_address, 9999999999999000000); // 9.999 ETH IERC20Dispatcher { contract_address: market.short_token } - .mint(deposit_vault.contract_address, 50000000000); + .mint(caller_address, 49999999999999999000000); // 49.999 UDC + 'filled account'.print(); + + // INITIAL LONG TOKEN IN POOL : 5 ETH + // INITIAL SHORT TOKEN IN POOL : 25000 USDC let balance_deposit_vault_before = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); + let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } + .balance_of(caller_address); + let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } + .balance_of(caller_address); + + assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); + assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); + assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); + + // Send token to deposit in the deposit vault (this should be in a multi call with create_deposit) + start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); + IERC20Dispatcher { contract_address: market.long_token } + .approve(caller_address, 50000000000000000000000000000); + IERC20Dispatcher { contract_address: market.short_token } + .approve(caller_address, 50000000000000000000000000000); + + IERC20Dispatcher { contract_address: market.long_token } + .mint(caller_address, 50000000000000000000000000000); // 20 ETH + IERC20Dispatcher { contract_address: market.short_token } + .mint(caller_address, 50000000000000000000000000000); // 100 000 USDC + + // role_store.grant_role(exchange_router.contract_address, role::ROUTER_PLUGIN); + // role_store.grant_role(caller_address, role::ROUTER_PLUGIN); + + exchange_router + .send_tokens( + market.long_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + exchange_router + .send_tokens( + market.short_token, deposit_vault.contract_address, 50000000000000000000000000000 + ); + + stop_prank(market.long_token); + stop_prank(market.short_token); // Create Deposit - let user1: ContractAddress = contract_address_const::<'user1'>(); - let user2: ContractAddress = contract_address_const::<'user2'>(); let addresss_zero: ContractAddress = 0.try_into().unwrap(); let params = CreateDepositParams { - receiver: user1, - callback_contract: user2, + receiver: caller_address, + callback_contract: addresss_zero, ui_fee_receiver: addresss_zero, market: market.market_token, initial_long_token: market.long_token, @@ -152,31 +212,36 @@ fn test_short_market_integration() { execution_fee: 0, callback_gas_limit: 0, }; + 'create deposit'.print(); start_roll(deposit_handler.contract_address, 1910); let key = deposit_handler.create_deposit(caller_address, params); let first_deposit = data_store.get_deposit(key); + 'created deposit'.print(); + assert(first_deposit.account == caller_address, 'Wrong account depositer'); - assert(first_deposit.receiver == user1, 'Wrong account receiver'); + assert(first_deposit.receiver == caller_address, 'Wrong account receiver'); assert(first_deposit.initial_long_token == market.long_token, 'Wrong initial long token'); assert( - first_deposit.initial_long_token_amount == 50000000000, 'Wrong initial long token amount' + first_deposit.initial_long_token_amount == 50000000000000000000000000000, + 'Wrong initial long token amount' ); assert( - first_deposit.initial_short_token_amount == 50000000000, 'Wrong init short token amount' + first_deposit.initial_short_token_amount == 50000000000000000000000000000, + 'Wrong init short token amount' ); - let price_params = SetPricesParams { // TODO - signer_info: 1, + let price_params = SetPricesParams { + signer_info: 0, tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], - compacted_min_oracle_block_numbers: array![1900, 1900], - compacted_max_oracle_block_numbers: array![1910, 1910], + compacted_min_oracle_block_numbers: array![1910, 1910], + compacted_max_oracle_block_numbers: array![1920, 1920], compacted_oracle_timestamps: array![9999, 9999], - compacted_decimals: array![18, 18], - compacted_min_prices: array![4294967346000000], // 50000000, 1000000 compacted + compacted_decimals: array![1, 1], + compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted compacted_min_prices_indexes: array![0], - compacted_max_prices: array![4294967346000000], // 50000000, 1000000 compacted + compacted_max_prices: array![4000, 1], // 500000, 10000 compacted compacted_max_prices_indexes: array![0], signatures: array![ array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() @@ -188,93 +253,88 @@ fn test_short_market_integration() { role_store.grant_role(caller_address, role::ORDER_KEEPER); role_store.grant_role(caller_address, role::ROLE_ADMIN); - role_store.grant_role(caller_address, role::CONTROLLER); + role_store.grant_role(exchange_router.contract_address, role::CONTROLLER); role_store.grant_role(caller_address, role::MARKET_KEEPER); + 'execute deposit'.print(); + // Execute Deposit start_roll(deposit_handler.contract_address, 1915); deposit_handler.execute_deposit(key, price_params); - let pool_value_info = market_utils::get_pool_value_info( - data_store, - market, - Price { min: 1999, max: 2000 }, - Price { min: 1999, max: 2000 }, - Price { min: 1999, max: 2000 }, - keys::max_pnl_factor_for_deposits(), - true, - ); - - assert(pool_value_info.pool_value.mag == 200000000000000, 'wrong pool value amount'); - assert(pool_value_info.long_token_amount == 50000000000, 'wrong long token amount'); - assert(pool_value_info.short_token_amount == 50000000000, 'wrong short token amount'); + 'executed deposit'.print(); let not_deposit = data_store.get_deposit(key); let default_deposit: Deposit = Default::default(); assert(not_deposit == default_deposit, 'Still existing deposit'); - // let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; + let market_token_dispatcher = IMarketTokenDispatcher { contract_address: market.market_token }; + let balance_market_token = market_token_dispatcher.balance_of(caller_address); - // let balance = market_token_dispatcher.balance_of(user1); + assert(balance_market_token != 0, 'should receive market token'); - let balance_deposit_vault = IERC20Dispatcher { contract_address: market.short_token } + let balance_deposit_vault_after = IERC20Dispatcher { contract_address: market.short_token } .balance_of(deposit_vault.contract_address); - let pool_value_info = market_utils::get_pool_value_info( - data_store, - market, - Price { min: 5000, max: 5000, }, - Price { min: 5000, max: 5000, }, - Price { min: 1, max: 1, }, - keys::max_pnl_factor_for_deposits(), - true, - ); + // let pool_value_info = market_utils::get_pool_value_info( + // data_store, + // market, + // Price { min: 5000, max: 5000, }, + // Price { min: 5000, max: 5000, }, + // Price { min: 1, max: 1, }, + // keys::max_pnl_factor_for_deposits(), + // true, + // ); - pool_value_info.pool_value.mag.print(); - pool_value_info.long_token_amount.print(); - pool_value_info.short_token_amount.print(); + // pool_value_info.pool_value.mag.print(); // 10000 000000000000000000 + // pool_value_info.long_token_amount.print(); // 5 000000000000000000 + // pool_value_info.short_token_amount.print(); // 25000 000000000000000000 // ************************************* TEST SHORT ********************************************* - 'begining of SHORT TEST'.print(); + 'Begining of SHORT TEST'.print(); let key_open_interest = keys::open_interest_key( - market.market_token, contract_address_const::<'ETH'>(), false - ); - data_store.set_u256(key_open_interest, 1); - let key_open_interest_usdc = keys::open_interest_key( market.market_token, contract_address_const::<'USDC'>(), false ); - data_store.set_u256(key_open_interest_usdc, 1); + data_store.set_u256(key_open_interest, 1); let max_key_open_interest = keys::max_open_interest_key(market.market_token, false); - data_store.set_u256(max_key_open_interest, 10000000000000000); + data_store + .set_u256( + max_key_open_interest, 1000000000000000000000000000000000000000000000000000 + ); // 1 000 000 + + let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } + .balance_of(caller_address); + let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } + .balance_of(caller_address); + + assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); + assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); + assert(balance_caller_USDC == 50000000000000000000000, 'USDC be 50 000 USDC'); - // start_prank(contract_address_const::<'USDC'>(), caller_address); - // // Send token to order_vault in multicall with create_order - // IERC20Dispatcher { contract_address: contract_address_const::<'USDC'>() } - // .transfer(order_vault.contract_address, 5000); - start_prank(contract_address_const::<'ETH'>(), caller_address); // Send token to order_vault in multicall with create_order - IERC20Dispatcher { contract_address: contract_address_const::<'ETH'>() } - .transfer(order_vault.contract_address, 3); + start_prank(contract_address_const::<'USDC'>(), caller_address); + IERC20Dispatcher { contract_address: contract_address_const::<'USDC'>() } + .transfer(order_vault.contract_address, 7000000000000000000000); // 7000 USDC 'transfer made'.print(); // Create order_params Struct let contract_address = contract_address_const::<0>(); start_prank(market.market_token, caller_address); - start_prank(market.long_token, caller_address); + start_prank(market.short_token, caller_address); let order_params_short = CreateOrderParams { receiver: caller_address, callback_contract: contract_address, ui_fee_receiver: contract_address, market: market.market_token, - initial_collateral_token: market.long_token, + initial_collateral_token: market.short_token, swap_path: Array32Trait::::span32(@array![]), - size_delta_usd: 10000, - initial_collateral_delta_amount: 2, // 10^18 - trigger_price: 5000, - acceptable_price: 0, - execution_fee: 1, + size_delta_usd: 7000000000000000000000, + initial_collateral_delta_amount: 7000000000000000000000, // 10^18 + trigger_price: 0, + acceptable_price: 1, + execution_fee: 0, callback_gas_limit: 0, min_output_amount: 0, order_type: OrderType::MarketIncrease(()), @@ -282,20 +342,28 @@ fn test_short_market_integration() { is_long: false, referral_code: 0 }; - // Create the swap order. - start_roll(order_handler.contract_address, 1940); - 'try to create prder'.print(); - start_prank(order_handler.contract_address, caller_address); - let key_short = order_handler.create_order(caller_address, order_params_short); + // Create the short order. + role_store.grant_role(exchange_router.contract_address, role::CONTROLLER); + start_roll(exchange_router.contract_address, 1930); + 'try to create order'.print(); + start_prank(exchange_router.contract_address, caller_address); + let key_short = exchange_router.create_order(order_params_short); 'short created'.print(); - let got_order_short = data_store.get_order(key_short); - // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); - // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); + + let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } + .balance_of(caller_address); + let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } + .balance_of(caller_address); + + assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); + assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); + assert(balance_caller_USDC == 43000000000000000000000, 'USDC be 50 000 USDC'); + // Execute the swap order. let signatures: Span = array![0].span(); let set_price_params = SetPricesParams { - signer_info: 2, + signer_info: 0, tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], compacted_min_oracle_block_numbers: array![1910, 1910], compacted_max_oracle_block_numbers: array![1920, 1920], @@ -303,7 +371,7 @@ fn test_short_market_integration() { compacted_decimals: array![1, 1], compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted compacted_min_prices_indexes: array![0], - compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted + compacted_max_prices: array![3500, 1], // 500000, 10000 compacted compacted_max_prices_indexes: array![0], signatures: array![ array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() @@ -316,89 +384,109 @@ fn test_short_market_integration() { stop_prank(order_handler.contract_address); start_prank(order_handler.contract_address, keeper_address); - start_roll(order_handler.contract_address, 1945); + start_roll(order_handler.contract_address, 1935); // TODO add real signatures check on Oracle Account - order_handler.execute_order_keeper(key_short, set_price_params, keeper_address); + order_handler.execute_order(key_short, set_price_params); 'short position SUCCEEDED'.print(); - let position_key_1 = position_utils::get_position_key( - caller_address, market.market_token, contract_address_const::<'ETH'>(), false - ); + + let position_key = data_store.get_account_position_keys(caller_address, 0, 10); + let position_key_1: felt252 = *position_key.at(0); let first_position = data_store.get_position(position_key_1); - // let market_prices = market_utils::MarketPrices { - // index_token_price: Price { min: 8000, max: 8000, }, - // long_token_price: Price { min: 8000, max: 8000, }, - // short_token_price: Price { min: 1, max: 1, }, - // }; - // 'size tokens'.print(); - // first_position.size_in_tokens.print(); - // 'size in usd'.print(); - // first_position.size_in_usd.print(); - - let second_swap_pool_value_info = market_utils::get_pool_value_info( - data_store, - market, - Price { min: 4000, max: 4000, }, - Price { min: 4000, max: 4000, }, - Price { min: 1, max: 1, }, - keys::max_pnl_factor_for_deposits(), - true, + + assert(first_position.size_in_tokens == 2000000000000000000, 'Size token should be 2 ETH'); + assert(first_position.size_in_usd == 7000000000000000000000, 'Size should be 7000$'); + assert(first_position.borrowing_factor == 0, 'Borrow should be 0'); + assert( + first_position.collateral_amount == 7000000000000000000000, 'Collat should be 7000 USDC' ); + assert(first_position.collateral_token == market.short_token, 'should be USDC'); - second_swap_pool_value_info.pool_value.mag.print(); - second_swap_pool_value_info.long_token_amount.print(); - second_swap_pool_value_info.short_token_amount.print(); - // let (position_pnl_usd, uncapped_position_pnl_usd, size_delta_in_tokens) = - // position_utils::get_position_pnl_usd( - // data_store, market, market_prices, first_position, 5000 - // ); - // position_pnl_usd.mag.print(); + // Test the PnL if the price goes up + let market_prices = market_utils::MarketPrices { + index_token_price: Price { min: 3850, max: 3850, }, + long_token_price: Price { min: 3850, max: 3850, }, + short_token_price: Price { min: 1, max: 1, }, + }; + + let position_info = reader + .get_position_info( + data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true + ); - //////////////////////////////////// CLOSING POSITION ////////////////////////////////////// - 'CLOOOOSE POSITION'.print(); + // The sign field is true for negative integers, and false for non-negative integers. + assert(position_info.base_pnl_usd.sign == true, 'should be negative'); + assert(position_info.base_pnl_usd.mag == 700000000000000000000, 'PnL should be -700$'); - let balance_of_mkt_before = IERC20Dispatcher { + let balance_caller_ETH = IERC20Dispatcher { contract_address: market.long_token } + .balance_of(caller_address); + let balance_caller_USDC = IERC20Dispatcher { contract_address: market.short_token } + .balance_of(caller_address); + + assert(balance_deposit_vault_before == 0, 'balance deposit should be 0'); + assert(balance_caller_ETH == 10000000000000000000, 'balanc ETH should be 10 ETH'); + assert(balance_caller_USDC == 43000000000000000000000, 'USDC be 43 000 USDC'); + + // //////////////////////////////////// CLOSE POSITION ////////////////////////////////////// + 'CLOSE POSITION'.print(); + + let balance_USDC_bef_close = IERC20Dispatcher { contract_address: contract_address_const::<'USDC'>() } .balance_of(caller_address); - 'balance of mkt before'.print(); - balance_of_mkt_before.print(); + + let balance_ETH_bef_close = IERC20Dispatcher { + contract_address: contract_address_const::<'ETH'>() + } + .balance_of(caller_address); + + let market_prices = market_utils::MarketPrices { + index_token_price: Price { min: 3000, max: 3000, }, + long_token_price: Price { min: 3000, max: 3000, }, + short_token_price: Price { min: 1, max: 1, }, + }; + + let position_info = reader + .get_position_info( + data_store, referal_storage, position_key_1, market_prices, 0, contract_address, true + ); + assert(position_info.base_pnl_usd.mag == 1000000000000000000000, 'PnL should be 1000$'); + assert(position_info.base_pnl_usd.sign == false, 'should be positive'); start_prank(market.market_token, caller_address); - start_prank(market.long_token, caller_address); - let order_params_long_dec = CreateOrderParams { + start_prank(market.short_token, caller_address); + let order_params_short_dec_2 = CreateOrderParams { receiver: caller_address, callback_contract: contract_address, ui_fee_receiver: contract_address, market: market.market_token, - initial_collateral_token: market.long_token, - swap_path: Array32Trait::::span32(@array![]), - size_delta_usd: 10000, // 12000 - initial_collateral_delta_amount: 2, // 2 ETH 10^18 - trigger_price: 5000, - acceptable_price: 0, + initial_collateral_token: market.short_token, + swap_path: Array32Trait::::span32(@array![market.market_token]), + size_delta_usd: 7000000000000000000000, // 7000 + initial_collateral_delta_amount: 7000000000000000000000, // 7000 USDC 10^18 + trigger_price: 0, + acceptable_price: 1, execution_fee: 0, callback_gas_limit: 0, - min_output_amount: 10000, // 12000 + min_output_amount: 0, order_type: OrderType::MarketDecrease(()), decrease_position_swap_type: DecreasePositionSwapType::NoSwap(()), is_long: false, referral_code: 0 }; - // Create the long order. - start_roll(order_handler.contract_address, 1940); + role_store.grant_role(exchange_router.contract_address, role::CONTROLLER); + start_roll(exchange_router.contract_address, 1960); 'try to create order'.print(); - start_prank(order_handler.contract_address, caller_address); - let key_long_dec = order_handler.create_order(caller_address, order_params_long_dec); - 'long decrease created'.print(); - let got_order_long_dec = data_store.get_order(key_long_dec); - // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'USDC'>()), ); - // data_store.set_u256(keys::pool_amount_key(market.market_token, contract_address_const::<'ETH'>()), 1000000); + start_prank(exchange_router.contract_address, caller_address); + let key_short_dec_2 = exchange_router.create_order(order_params_short_dec_2); + 'short decrease created'.print(); + // Execute the swap order. + let keeper_address = contract_address_const::<'keeper'>(); + role_store.grant_role(keeper_address, role::ORDER_KEEPER); - let signatures: Span = array![0].span(); - let set_price_params_dec = SetPricesParams { - signer_info: 2, + let set_price_params_dec2 = SetPricesParams { + signer_info: 0, tokens: array![contract_address_const::<'ETH'>(), contract_address_const::<'USDC'>()], compacted_min_oracle_block_numbers: array![1910, 1910], compacted_max_oracle_block_numbers: array![1920, 1920], @@ -406,7 +494,7 @@ fn test_short_market_integration() { compacted_decimals: array![1, 1], compacted_min_prices: array![2147483648010000], // 500000, 10000 compacted compacted_min_prices_indexes: array![0], - compacted_max_prices: array![2147483648010000], // 500000, 10000 compacted + compacted_max_prices: array![3000, 1], // 500000, 10000 compacted compacted_max_prices_indexes: array![0], signatures: array![ array!['signatures1', 'signatures2'].span(), array!['signatures1', 'signatures2'].span() @@ -414,663 +502,37 @@ fn test_short_market_integration() { price_feed_tokens: array![] }; - let keeper_address = contract_address_const::<'keeper'>(); - role_store.grant_role(keeper_address, role::ORDER_KEEPER); - stop_prank(order_handler.contract_address); start_prank(order_handler.contract_address, keeper_address); - start_roll(order_handler.contract_address, 1945); + start_roll(order_handler.contract_address, 1965); // TODO add real signatures check on Oracle Account - order_handler.execute_order_keeper(key_long_dec, set_price_params_dec, keeper_address); - 'long pos dec SUCCEEDED'.print(); - - let first_position_dec = data_store.get_position(position_key_1); + order_handler.execute_order(key_short_dec_2, set_price_params_dec2); + 'Short pos close SUCCEEDED'.print(); - 'size tokens before'.print(); - first_position.size_in_tokens.print(); - 'size in usd before'.print(); - first_position.size_in_usd.print(); + let first_position_close = data_store.get_position(position_key_1); - 'size tokens'.print(); - first_position_dec.size_in_tokens.print(); - 'size in usd'.print(); - first_position_dec.size_in_usd.print(); + assert(first_position_close.size_in_tokens == 0, 'Size token should be 0'); + assert(first_position_close.size_in_usd == 0, 'Size should be 0'); + assert(first_position_close.borrowing_factor == 0, 'Borrow should be 0'); + assert(first_position_close.collateral_amount == 0, 'Collat should be 0'); - let balance_of_mkt_after = IERC20Dispatcher { + let balance_USDC_af_close = IERC20Dispatcher { contract_address: contract_address_const::<'USDC'>() } .balance_of(caller_address); - 'balance of mkt after'.print(); - balance_of_mkt_after.print(); + + let balance_ETH_af_close = IERC20Dispatcher { + contract_address: contract_address_const::<'ETH'>() + } + .balance_of(caller_address); + + assert(balance_USDC_bef_close == 43000000000000000000000, 'balance USDC shld be 43000$'); + assert(balance_USDC_af_close == 43000000000000000000000, 'balance USDC shld be 43000$'); + assert(balance_ETH_af_close == 12666666666666666666, 'balance ETH should be 12.66'); + assert(balance_ETH_bef_close == 10000000000000000000, 'balance ETH should be 10'); // ********************************************************************************************* // * TEARDOWN * // ********************************************************************************************* teardown(data_store, market_factory); } - -fn create_market(market_factory: IMarketFactoryDispatcher) -> ContractAddress { - // Create a market. - let (index_token, short_token) = deploy_tokens(); - let market_type = 'market_type'; - - // Index token is the same as long token here. - market_factory.create_market(index_token, index_token, short_token, market_type) -} - -/// Utility functions to deploy tokens for a market. -fn deploy_tokens() -> (ContractAddress, ContractAddress) { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let contract = declare('ERC20'); - - let eth_address = contract_address_const::<'ETH'>(); - let constructor_calldata = array!['Ethereum', 'ETH', 1000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, eth_address).unwrap(); - - let usdc_address = contract_address_const::<'USDC'>(); - let constructor_calldata = array!['usdc', 'USDC', 1000000, 0, caller_address.into()]; - contract.deploy_at(@constructor_calldata, usdc_address).unwrap(); - (eth_address, usdc_address) -} - -/// Utility function to setup the test environment. -fn setup() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, -) { - let ( - caller_address, - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - ) = - setup_contracts(); - grant_roles_and_prank(caller_address, role_store, data_store, market_factory); - ( - caller_address, - market_factory.contract_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - ) -} - -// Utility function to grant roles and prank the caller address. -/// Grants roles and pranks the caller address. -/// -/// # Arguments -/// -/// * `caller_address` - The address of the caller. -/// * `role_store` - The interface to interact with the `RoleStore` contract. -/// * `data_store` - The interface to interact with the `DataStore` contract. -/// * `market_factory` - The interface to interact with the `MarketFactory` contract. -fn grant_roles_and_prank( - caller_address: ContractAddress, - role_store: IRoleStoreDispatcher, - data_store: IDataStoreDispatcher, - market_factory: IMarketFactoryDispatcher, -) { - start_prank(role_store.contract_address, caller_address); - - // Grant the caller the `CONTROLLER` role. - role_store.grant_role(caller_address, role::CONTROLLER); - - // Grant the call the `MARKET_KEEPER` role. - // This role is required to create a market. - role_store.grant_role(caller_address, role::MARKET_KEEPER); - - // Prank the caller address for calls to `DataStore` contract. - // We need this so that the caller has the CONTROLLER role. - start_prank(data_store.contract_address, caller_address); - - // Start pranking the `MarketFactory` contract. This is necessary to mock the behavior of the contract - // for testing purposes. - start_prank(market_factory.contract_address, caller_address); -} - -/// Utility function to teardown the test environment. -fn teardown(data_store: IDataStoreDispatcher, market_factory: IMarketFactoryDispatcher) { - stop_prank(data_store.contract_address); - stop_prank(market_factory.contract_address); -} - -/// Setup required contracts. -fn setup_contracts() -> ( - // This caller address will be used with `start_prank` cheatcode to mock the caller address., - ContractAddress, - // Address of the `MarketFactory` contract. - ContractAddress, - // Address of the `RoleStore` contract. - ContractAddress, - // Address of the `DataStore` contract. - ContractAddress, - // The `MarketToken` class hash for the factory. - ContractClass, - // Interface to interact with the `MarketFactory` contract. - IMarketFactoryDispatcher, - // Interface to interact with the `RoleStore` contract. - IRoleStoreDispatcher, - // Interface to interact with the `DataStore` contract. - IDataStoreDispatcher, - // Interface to interact with the `EventEmitter` contract. - IEventEmitterDispatcher, - // Interface to interact with the `ExchangeRouter` contract. - IExchangeRouterDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositHandlerDispatcher, - // Interface to interact with the `DepositHandler` contract. - IDepositVaultDispatcher, - IOracleDispatcher, - IOrderHandlerDispatcher, - IOrderVaultDispatcher, - IReaderDispatcher, - IReferralStorageDispatcher, - IWithdrawalHandlerDispatcher, - IWithdrawalVaultDispatcher, -) { - // Deploy the role store contract. - let role_store_address = deploy_role_store(); - - // Create a role store dispatcher. - let role_store = IRoleStoreDispatcher { contract_address: role_store_address }; - - // Deploy the contract. - let data_store_address = deploy_data_store(role_store_address); - // Create a safe dispatcher to interact with the contract. - let data_store = IDataStoreDispatcher { contract_address: data_store_address }; - - // Declare the `MarketToken` contract. - let market_token_class_hash = declare_market_token(); - - // Deploy the event emitter contract. - let event_emitter_address = deploy_event_emitter(); - // Create a safe dispatcher to interact with the contract. - let event_emitter = IEventEmitterDispatcher { contract_address: event_emitter_address }; - - // Deploy the router contract. - let router_address = deploy_router(role_store_address); - - // Deploy the market factory. - let market_factory_address = deploy_market_factory( - data_store_address, role_store_address, event_emitter_address, market_token_class_hash - ); - // Create a safe dispatcher to interact with the contract. - let market_factory = IMarketFactoryDispatcher { contract_address: market_factory_address }; - - let oracle_store_address = deploy_oracle_store(role_store_address, event_emitter_address); - let oracle_address = deploy_oracle( - role_store_address, oracle_store_address, contract_address_const::<'pragma'>() - ); - - let oracle = IOracleDispatcher { contract_address: oracle_address }; - - let deposit_vault_address = deploy_deposit_vault(role_store_address, data_store_address); - - let deposit_vault = IDepositVaultDispatcher { contract_address: deposit_vault_address }; - let deposit_handler_address = deploy_deposit_handler( - data_store_address, - role_store_address, - event_emitter_address, - deposit_vault_address, - oracle_address - ); - let deposit_handler = IDepositHandlerDispatcher { contract_address: deposit_handler_address }; - - let withdrawal_vault_address = deploy_withdrawal_vault(data_store_address, role_store_address); - let withdrawal_handler_address = deploy_withdrawal_handler( - data_store_address, - role_store_address, - event_emitter_address, - withdrawal_vault_address, - oracle_address - ); - - let order_vault_address = deploy_order_vault( - data_store.contract_address, role_store.contract_address - ); - let order_vault = IOrderVaultDispatcher { contract_address: order_vault_address }; - - let swap_handler_address = deploy_swap_handler_address(role_store_address, data_store_address); - let referral_storage_address = deploy_referral_storage(event_emitter_address); - let increase_order_class_hash = declare_increase_order(); - let decrease_order_class_hash = declare_decrease_order(); - let swap_order_class_hash = declare_swap_order(); - - let order_utils_class_hash = declare_order_utils(); - - let order_handler_address = deploy_order_handler( - data_store_address, - role_store_address, - event_emitter_address, - order_vault_address, - oracle_address, - swap_handler_address, - referral_storage_address, - order_utils_class_hash, - increase_order_class_hash, - decrease_order_class_hash, - swap_order_class_hash - ); - let order_handler = IOrderHandlerDispatcher { contract_address: order_handler_address }; - - let exchange_router_address = deploy_exchange_router( - router_address, - data_store_address, - role_store_address, - event_emitter_address, - deposit_handler_address, - withdrawal_handler_address, - order_handler_address - ); - let exchange_router = IExchangeRouterDispatcher { contract_address: exchange_router_address }; - - let bank_address = deploy_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the Bank contract. - let bank = IBankDispatcher { contract_address: bank_address }; - - // Deploy the strict bank contract - let strict_bank_address = deploy_strict_bank(data_store_address, role_store_address); - - //Create a safe dispatcher to interact with the StrictBank contract. - let strict_bank = IStrictBankDispatcher { contract_address: strict_bank_address }; - - let reader_address = deploy_reader(); - let reader = IReaderDispatcher { contract_address: reader_address }; - - let referal_storage = IReferralStorageDispatcher { contract_address: referral_storage_address }; - - let withdrawal_handler = IWithdrawalHandlerDispatcher { - contract_address: withdrawal_handler_address - }; - let withdrawal_vault = IWithdrawalVaultDispatcher { - contract_address: withdrawal_vault_address - }; - ( - contract_address_const::<'caller'>(), - market_factory_address, - role_store_address, - data_store_address, - market_token_class_hash, - market_factory, - role_store, - data_store, - event_emitter, - exchange_router, - deposit_handler, - deposit_vault, - oracle, - order_handler, - order_vault, - reader, - referal_storage, - withdrawal_handler, - withdrawal_vault, - ) -} - -/// Utility function to declare a `MarketToken` contract. -fn declare_market_token() -> ContractClass { - declare('MarketToken') -} - -/// Utility function to deploy a market factory contract and return its address. -fn deploy_market_factory( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - market_token_class_hash: ContractClass, -) -> ContractAddress { - let contract = declare('MarketFactory'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'market_factory'>(); - start_prank(deployed_contract_address, caller_address); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - constructor_calldata.append(event_emitter_address.into()); - constructor_calldata.append(market_token_class_hash.class_hash.into()); - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - - -fn deploy_data_store(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('DataStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address: ContractAddress = 0x1.try_into().unwrap(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_role_store() -> ContractAddress { - let contract = declare('RoleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'role_store'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![caller_address.into()], deployed_contract_address).unwrap() -} - -fn deploy_event_emitter() -> ContractAddress { - let contract = declare('EventEmitter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'event_emitter'>(); - start_prank(deployed_contract_address, caller_address); - contract.deploy_at(@array![], deployed_contract_address).unwrap() -} - -fn deploy_router(role_store_address: ContractAddress) -> ContractAddress { - let contract = declare('Router'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_deposit_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_handler'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_vault_address.into(), - oracle_address.into() - ], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle_store( - role_store_address: ContractAddress, event_emitter_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OracleStore'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle_store'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), event_emitter_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_oracle( - role_store_address: ContractAddress, - oracle_store_address: ContractAddress, - pragma_address: ContractAddress -) -> ContractAddress { - let contract = declare('Oracle'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'oracle'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![role_store_address.into(), oracle_store_address.into(), pragma_address.into()], - deployed_contract_address - ) - .unwrap() -} - -fn deploy_deposit_vault( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('DepositVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'deposit_vault'>(); - start_prank(deployed_contract_address, caller_address); - contract - .deploy_at( - @array![data_store_address.into(), role_store_address.into()], deployed_contract_address - ) - .unwrap() -} - -fn deploy_withdrawal_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - withdrawal_vault_address: ContractAddress, - oracle_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - withdrawal_vault_address.into(), - oracle_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_withdrawal_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('WithdrawalVault'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'withdrawal_vault'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![data_store_address.into(), role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_handler( - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - order_vault_address: ContractAddress, - oracle_address: ContractAddress, - swap_handler_address: ContractAddress, - referral_storage_address: ContractAddress, - order_utils_class_hash: ClassHash, - increase_order_class_hash: ClassHash, - decrease_order_class_hash: ClassHash, - swap_order_class_hash: ClassHash -) -> ContractAddress { - let contract = declare('OrderHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'order_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - order_vault_address.into(), - oracle_address.into(), - swap_handler_address.into(), - referral_storage_address.into(), - order_utils_class_hash.into(), - increase_order_class_hash.into(), - decrease_order_class_hash.into(), - swap_order_class_hash.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_swap_handler_address( - role_store_address: ContractAddress, data_store_address: ContractAddress -) -> ContractAddress { - let contract = declare('SwapHandler'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'swap_handler'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![role_store_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_referral_storage(event_emitter_address: ContractAddress) -> ContractAddress { - let contract = declare('ReferralStorage'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'referral_storage'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![event_emitter_address.into()]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_exchange_router( - router_address: ContractAddress, - data_store_address: ContractAddress, - role_store_address: ContractAddress, - event_emitter_address: ContractAddress, - deposit_handler_address: ContractAddress, - withdrawal_handler_address: ContractAddress, - order_handler_address: ContractAddress -) -> ContractAddress { - let contract = declare('ExchangeRouter'); - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let deployed_contract_address = contract_address_const::<'exchange_router'>(); - start_prank(deployed_contract_address, caller_address); - let constructor_calldata = array![ - router_address.into(), - data_store_address.into(), - role_store_address.into(), - event_emitter_address.into(), - deposit_handler_address.into(), - withdrawal_handler_address.into(), - order_handler_address.into() - ]; - contract.deploy_at(@constructor_calldata, deployed_contract_address).unwrap() -} - -fn deploy_order_vault( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let contract = declare('OrderVault'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - tests_lib::deploy_mock_contract(contract, @constructor_calldata) -} - -fn declare_increase_order() -> ClassHash { - declare('IncreaseOrderUtils').class_hash -} -fn declare_decrease_order() -> ClassHash { - declare('DecreaseOrderUtils').class_hash -} -fn declare_swap_order() -> ClassHash { - declare('SwapOrderUtils').class_hash -} - - -fn declare_order_utils() -> ClassHash { - declare('OrderUtils').class_hash -} - -fn deploy_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let bank_address: ContractAddress = contract_address_const::<'bank'>(); - let contract = declare('Bank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(data_store_address, caller_address); - contract.deploy_at(@constructor_calldata, bank_address).unwrap() -} - -fn deploy_strict_bank( - data_store_address: ContractAddress, role_store_address: ContractAddress, -) -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let strict_bank_address: ContractAddress = contract_address_const::<'strict_bank'>(); - let contract = declare('StrictBank'); - let mut constructor_calldata = array![]; - constructor_calldata.append(data_store_address.into()); - constructor_calldata.append(role_store_address.into()); - start_prank(strict_bank_address, caller_address); - contract.deploy_at(@constructor_calldata, strict_bank_address).unwrap() -} - -fn deploy_reader() -> ContractAddress { - let caller_address: ContractAddress = contract_address_const::<'caller'>(); - let reader_address: ContractAddress = contract_address_const::<'reader'>(); - let contract = declare('Reader'); - let mut constructor_calldata = array![]; - start_prank(reader_address, caller_address); - contract.deploy_at(@constructor_calldata, reader_address).unwrap() -} - -fn deploy_erc20_token(deposit_vault_address: ContractAddress) -> ContractAddress { - let erc20_contract = declare('ERC20'); - let constructor_calldata3 = array![ - 'satoru', 'STU', INITIAL_TOKENS_MINTED, 0, deposit_vault_address.into() - ]; - erc20_contract.deploy(@constructor_calldata3).unwrap() -} diff --git a/tests/lib.cairo b/tests/lib.cairo index e788a69e..fe471ec9 100644 --- a/tests/lib.cairo +++ b/tests/lib.cairo @@ -122,7 +122,7 @@ mod integration { // mod test_deposit_withdrawal; - // mod test_short_integration; + mod test_short_integration; // mod test_swap_integration; mod test_long_integration; mod swap_test;