fix: rename core modules to dt_ prefix to resolve namespace collisions

packages/deeptrade-core/sources/fee.move

@@ -2,6 +2,7 @@ module deeptrade_core::fee;
 
 use deepbook::constants::fee_penalty_multiplier;
 use deepbook::pool::Pool;
+use deeptrade_core::dt_math as math;
 use deeptrade_core::helper::{
     calculate_deep_required,
     calculate_order_amount,
@@ -12,7 +13,6 @@ use deeptrade_core::helper::{
     apply_discount
 };
 use deeptrade_core::loyalty::LoyaltyProgram;
-use deeptrade_core::math;
 use deeptrade_core::ticket::{
     AdminTicket,
     validate_ticket,

packages/deeptrade-core/sources/fee_manager.move

@@ -5,7 +5,7 @@ use deepbook::constants::{live, partially_filled};
 use deepbook::order_info::OrderInfo;
 use deepbook::pool::Pool;
 use deeptrade_core::admin::AdminCap;
-use deeptrade_core::math;
+use deeptrade_core::dt_math as math;
 use deeptrade_core::multisig_config::MultisigConfig;
 use deeptrade_core::treasury::{Treasury, join_protocol_fee};
 use sui::bag::{Self, Bag};

packages/deeptrade-core/sources/helper.move

@@ -2,7 +2,7 @@ module deeptrade_core::helper;
 
 use deepbook::constants::{live, partially_filled};
 use deepbook::pool::Pool;
-use deeptrade_core::math;
+use deeptrade_core::dt_math as math;
 use deeptrade_core::oracle;
 use pyth::price_info::PriceInfoObject;
 use std::type_name;

packages/deeptrade-core/sources/math.move

@@ -2,7 +2,7 @@
 // Copyright (c) Deeptrade
 // SPDX-License-Identifier: Apache-2.0
 
-module deeptrade_core::math;
+module deeptrade_core::dt_math;
 
 /// scaling setting for float
 const FLOAT_SCALING_U128: u128 = 1_000_000_000;

packages/deeptrade-core/sources/order.move

@@ -1,4 +1,4 @@
-module deeptrade_core::order;
+module deeptrade_core::dt_order;
 
 use deepbook::balance_manager::{BalanceManager, TradeProof};
 use deepbook::constants;

packages/deeptrade-core/sources/pool.move

@@ -1,4 +1,4 @@
-module deeptrade_core::pool;
+module deeptrade_core::dt_pool;
 
 use deepbook::constants;
 use deepbook::pool;

packages/deeptrade-core/tests/core/create_order_core.move

@@ -1,9 +1,7 @@
 #[test_only]
 module deeptrade_core::create_order_core_tests;
 
-use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
-use deeptrade_core::helper::calculate_order_amount;
-use deeptrade_core::order::{
+use deeptrade_core::dt_order::{
     create_order_core,
     assert_deep_plan_eq,
     assert_coverage_fee_plan_eq,
@@ -13,6 +11,8 @@ use deeptrade_core::order::{
     InputCoinDepositPlan,
     EInvalidInputCoinType
 };
+use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
+use deeptrade_core::helper::calculate_order_amount;
 use std::unit_test::assert_eq;
 
 // ===== Constants =====

packages/deeptrade-core/tests/fee/validate_fees_against_max.move

@@ -1,14 +1,14 @@
 #[test_only]
 module deeptrade_core::validate_fees_against_max_tests;
 
-use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
-use deeptrade_core::helper::apply_slippage;
-use deeptrade_core::order::{
+use deeptrade_core::dt_order::{
     validate_fees_against_max,
     EDeepRequiredExceedsMax,
     ECoverageFeeExceedsMax,
     EInvalidSlippage
 };
+use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
+use deeptrade_core::helper::apply_slippage;
 use std::unit_test::assert_eq;
 
 #[test]

packages/deeptrade-core/tests/helpers/apply_discount_tests.move

@@ -1,8 +1,8 @@
 #[test_only]
 module deeptrade_core::apply_discount_tests;
 
+use deeptrade_core::dt_math as math;
 use deeptrade_core::helper::{Self, EInvalidDiscountRate};
-use deeptrade_core::math;
 use std::unit_test::assert_eq;
 
 /// Test that applying zero discount returns the original value

packages/deeptrade-core/tests/helpers/apply_slippage_tests.move

@@ -1,8 +1,8 @@
 #[test_only]
 module deeptrade_core::apply_slippage_tests;
 
+use deeptrade_core::dt_math as math;
 use deeptrade_core::helper;
-use deeptrade_core::math;
 use std::unit_test::assert_eq;
 
 /// Test that applying slippage to zero value returns zero

packages/deeptrade-core/tests/helpers/plan_fee_collection_tests.move

@@ -1,7 +1,7 @@
 #[test_only]
 module deeptrade_core::plan_fee_collection_tests;
 
-use deeptrade_core::order;
+use deeptrade_core::dt_order as order;
 use std::unit_test::assert_eq;
 
 /// Test that planning fee collection with zero fee returns zeros

packages/deeptrade-core/tests/math_tests.move

@@ -2,7 +2,7 @@
 module deeptrade_core::math_tests;
 
 use deepbook::constants::max_u64;
-use deeptrade_core::math;
+use deeptrade_core::dt_math as math;
 use std::unit_test::assert_eq;
 
 /// This test demonstrates why using the scaled-math functions (`mul`, `div`)

packages/deeptrade-core/tests/order/cancel_order_and_settle_fees_tests.move

@@ -10,8 +10,8 @@ use deepbook::pool_tests::{
     setup_pool_with_default_fees_and_reference_pool,
     place_limit_order
 };
+use deeptrade_core::dt_order::cancel_order_and_settle_fees;
 use deeptrade_core::fee_manager::{Self, FeeManager};
-use deeptrade_core::order::cancel_order_and_settle_fees;
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::balance;

packages/deeptrade-core/tests/order/charge_protocol_fees_tests.move

@@ -7,10 +7,10 @@ use deepbook::constants;
 use deepbook::order_info::{Self, OrderInfo};
 use deepbook::pool::Pool;
 use deepbook::pool_tests::{setup_test, setup_pool_with_default_fees};
+use deeptrade_core::dt_order::charge_protocol_fees;
 use deeptrade_core::fee::{Self, TradingFeeConfig};
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::helper::calculate_order_taker_maker_ratio;
-use deeptrade_core::order::charge_protocol_fees;
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;

packages/deeptrade-core/tests/order/create_limit_order_input_fee_tests.move

@@ -6,10 +6,10 @@ use deepbook::balance_manager_tests::USDC;
 use deepbook::constants;
 use deepbook::pool::Pool;
 use deeptrade_core::create_market_order_input_fee_tests::setup_test_environment;
+use deeptrade_core::dt_order::{Self as order, create_limit_order_input_fee};
 use deeptrade_core::fee::TradingFeeConfig;
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::loyalty::LoyaltyProgram;
-use deeptrade_core::order::{Self, create_limit_order_input_fee};
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::clock::Clock;

packages/deeptrade-core/tests/order/create_limit_order_tests.move

@@ -6,10 +6,10 @@ use deepbook::balance_manager_tests::{USDC, create_acct_and_share_with_funds};
 use deepbook::constants;
 use deepbook::pool::Pool;
 use deeptrade_core::create_market_order_tests::setup_test_environment;
+use deeptrade_core::dt_order::{Self as order, create_limit_order};
 use deeptrade_core::fee::TradingFeeConfig;
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::loyalty::LoyaltyProgram;
-use deeptrade_core::order::{Self, create_limit_order};
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::clock;

packages/deeptrade-core/tests/order/create_limit_order_whitelisted_tests.move

@@ -6,10 +6,10 @@ use deepbook::balance_manager_tests::USDC;
 use deepbook::constants;
 use deepbook::pool::Pool;
 use deeptrade_core::create_market_order_input_fee_tests::setup_test_environment;
+use deeptrade_core::dt_order::{Self as order, create_limit_order_whitelisted};
 use deeptrade_core::fee::TradingFeeConfig;
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::loyalty::LoyaltyProgram;
-use deeptrade_core::order::{Self, create_limit_order_whitelisted};
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::clock::Clock;

packages/deeptrade-core/tests/order/create_market_order_input_fee_tests.move

@@ -10,11 +10,11 @@ use deepbook::pool_tests::{
     setup_pool_with_default_fees_and_reference_pool,
     place_limit_order
 };
+use deeptrade_core::dt_math as math;
+use deeptrade_core::dt_order::{Self as order, create_market_order_input_fee};
 use deeptrade_core::fee::{Self, TradingFeeConfig};
 use deeptrade_core::fee_manager::{Self, FeeManager};
 use deeptrade_core::loyalty::{Self, LoyaltyProgram};
-use deeptrade_core::math;
-use deeptrade_core::order::{Self, create_market_order_input_fee};
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::clock::Clock;

packages/deeptrade-core/tests/order/create_market_order_tests.move

@@ -13,15 +13,15 @@ use deepbook::pool_tests::{
     add_deep_price_point,
     set_time
 };
+use deeptrade_core::dt_math as math;
+use deeptrade_core::dt_order::{Self as order, create_market_order};
 use deeptrade_core::fee::{Self, TradingFeeConfig};
 use deeptrade_core::fee_manager::{Self, FeeManager};
 use deeptrade_core::get_sui_per_deep_from_oracle_tests::{
     new_deep_price_object,
     new_sui_price_object
 };
 use deeptrade_core::loyalty::{Self, LoyaltyProgram};
-use deeptrade_core::math;
-use deeptrade_core::order::{Self, create_market_order};
 use deeptrade_core::treasury;
 use pyth::price_info::PriceInfoObject;
 use std::unit_test::assert_eq;

packages/deeptrade-core/tests/order/create_market_order_whitelisted_tests.move

@@ -7,11 +7,11 @@ use deepbook::constants;
 use deepbook::pool::Pool;
 use deepbook::pool_tests::place_limit_order;
 use deeptrade_core::create_market_order_input_fee_tests::setup_test_environment;
+use deeptrade_core::dt_math as math;
+use deeptrade_core::dt_order::{Self as order, create_market_order_whitelisted};
 use deeptrade_core::fee::TradingFeeConfig;
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::loyalty::LoyaltyProgram;
-use deeptrade_core::math;
-use deeptrade_core::order::{Self, create_market_order_whitelisted};
 use deeptrade_core::treasury;
 use std::unit_test::assert_eq;
 use sui::clock::Clock;

packages/deeptrade-core/tests/order/prepare_input_fee_order_execution_tests.move

@@ -5,7 +5,7 @@ use deepbook::balance_manager::BalanceManager;
 use deepbook::balance_manager_tests::{create_acct_and_share_with_funds, USDC};
 use deepbook::pool::Pool;
 use deepbook::pool_tests::{setup_test, setup_pool_with_default_fees};
-use deeptrade_core::order::prepare_input_fee_order_execution;
+use deeptrade_core::dt_order::prepare_input_fee_order_execution;
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;
 use sui::sui::SUI;
@@ -200,7 +200,7 @@ fun ask_success() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInvalidOwner)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInvalidOwner)]
 fun invalid_owner_aborts() {
     // Test-specific constants
     let order_amount = 5_000 * TOKEN_MULTIPLIER; // 5,000 quote tokens for bid

packages/deeptrade-core/tests/order/prepare_order_execution_tests.move

@@ -6,14 +6,14 @@ use deepbook::balance_manager_tests::{create_acct_and_share_with_funds, USDC};
 use deepbook::constants;
 use deepbook::pool::Pool;
 use deepbook::pool_tests::{setup_test, setup_pool_with_default_fees, setup_reference_pool};
+use deeptrade_core::dt_order::prepare_order_execution;
 use deeptrade_core::fee::{Self, TradingFeeConfig};
 use deeptrade_core::get_sui_per_deep_from_oracle_tests::{
     new_deep_price_object,
     new_sui_price_object
 };
 use deeptrade_core::helper::hundred_percent;
 use deeptrade_core::loyalty::{Self, LoyaltyProgram};
-use deeptrade_core::order::prepare_order_execution;
 use deeptrade_core::treasury::{Self, Treasury};
 use pyth::price_info;
 use std::unit_test::assert_eq;
@@ -486,7 +486,7 @@ fun ask_success() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInvalidOwner)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInvalidOwner)]
 fun invalid_owner_aborts() {
     // This test verifies that prepare_order_execution aborts when called by someone
     // who is not the owner of the balance manager

packages/deeptrade-core/tests/order/prepare_whitelisted_order_execution_tests.move

@@ -5,10 +5,10 @@ use deepbook::balance_manager::BalanceManager;
 use deepbook::balance_manager_tests::{create_acct_and_share_with_funds, USDC};
 use deepbook::pool::Pool;
 use deepbook::pool_tests::{setup_test, setup_pool_with_default_fees};
+use deeptrade_core::dt_order::prepare_whitelisted_order_execution;
 use deeptrade_core::fee::{Self, TradingFeeConfig};
 use deeptrade_core::helper::hundred_percent;
 use deeptrade_core::loyalty::{Self, LoyaltyProgram};
-use deeptrade_core::order::prepare_whitelisted_order_execution;
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;
 use sui::sui::SUI;
@@ -235,7 +235,7 @@ fun ask_success() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInvalidOwner)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInvalidOwner)]
 fun invalid_owner_aborts() {
     // Test-specific constants
     let order_amount = 5_000 * TOKEN_MULTIPLIER; // 5,000 quote tokens for bid

packages/deeptrade-core/tests/plans/execute_coverage_fee_plan_tests.move

@@ -3,12 +3,12 @@ module deeptrade_core::execute_coverage_fee_plan_tests;
 
 use deepbook::balance_manager::BalanceManager;
 use deepbook::balance_manager_tests::create_acct_and_share_with_funds;
-use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
-use deeptrade_core::order::{
+use deeptrade_core::dt_order::{
     execute_coverage_fee_plan,
     get_coverage_fee_plan,
     assert_coverage_fee_plan_eq
 };
+use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
 use deeptrade_core::treasury::{Self, Treasury};
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;
@@ -334,7 +334,7 @@ fun coverage_fee_from_balance_manager_only() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInsufficientFee)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInsufficientFee)]
 fun insufficient_fee_aborts() {
     // Test-specific constants
     let deep_from_reserves = 60_000 * DEEP_MULTIPLIER; // 60,000 DEEP taken from treasury

packages/deeptrade-core/tests/plans/execute_deep_plan_tests.move

@@ -3,7 +3,7 @@ module deeptrade_core::execute_deep_plan_tests;
 
 use deepbook::balance_manager::BalanceManager;
 use deepbook::balance_manager_tests::create_acct_and_share_with_funds;
-use deeptrade_core::order::{execute_deep_plan, get_deep_plan, assert_deep_plan_eq};
+use deeptrade_core::dt_order::{execute_deep_plan, get_deep_plan, assert_deep_plan_eq};
 use deeptrade_core::treasury::{Self, Treasury};
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;
@@ -125,7 +125,7 @@ fun deep_from_both_wallet_and_treasury_reserves() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInsufficientDeepReserves)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInsufficientDeepReserves)]
 fun insufficient_deep_reserves_aborts() {
     // Test-specific constants
     let deep_required = 5_000 * DEEP_MULTIPLIER; // 5,000 DEEP total needed

packages/deeptrade-core/tests/plans/execute_input_coin_deposit_plan_tests.move

@@ -3,7 +3,7 @@ module deeptrade_core::execute_input_coin_deposit_plan_tests;
 
 use deepbook::balance_manager::BalanceManager;
 use deepbook::balance_manager_tests::{create_acct_and_share_with_funds, USDC, SPAM};
-use deeptrade_core::order::{
+use deeptrade_core::dt_order::{
     execute_input_coin_deposit_plan,
     get_input_coin_deposit_plan,
     assert_input_coin_deposit_plan_eq
@@ -211,7 +211,7 @@ fun input_coin_deposit_ask_from_wallet() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInsufficientInput)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInsufficientInput)]
 fun insufficient_input_coin_aborts() {
     // Test-specific constants
     let required_amount = 10_000 * TOKEN_MULTIPLIER; // 10,000 tokens needed

packages/deeptrade-core/tests/plans/execute_protocol_fee_plan_tests.move

@@ -6,10 +6,10 @@ use deepbook::balance_manager_tests::create_acct_and_share_with_funds;
 use deepbook::constants;
 use deepbook::order_info::{Self, OrderInfo};
 use deeptrade_core::add_to_user_unsettled_fees_tests::setup_fee_manager_test;
+use deeptrade_core::dt_order::{execute_protocol_fee_plan, get_protocol_fee_plan};
 use deeptrade_core::fee::calculate_protocol_fees;
 use deeptrade_core::fee_manager::FeeManager;
 use deeptrade_core::helper::calculate_order_taker_maker_ratio;
-use deeptrade_core::order::{execute_protocol_fee_plan, get_protocol_fee_plan};
 use std::unit_test::assert_eq;
 use sui::coin::mint_for_testing;
 use sui::object::id_from_address;
@@ -170,7 +170,7 @@ fun both_taker_and_maker_fees_from_both_sources() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = deeptrade_core::order::EInsufficientFee)]
+#[test, expected_failure(abort_code = deeptrade_core::dt_order::EInsufficientFee)]
 fun insufficient_fee_aborts() {
     let mut scenario = setup_fee_manager_test(ALICE);
 

packages/deeptrade-core/tests/plans/get_coverage_fee_plan.move

@@ -1,8 +1,8 @@
 #[test_only]
 module deeptrade_core::get_coverage_fee_plan_tests;
 
+use deeptrade_core::dt_order::{get_coverage_fee_plan, assert_coverage_fee_plan_eq};
 use deeptrade_core::fee::calculate_deep_reserves_coverage_order_fee;
-use deeptrade_core::order::{get_coverage_fee_plan, assert_coverage_fee_plan_eq};
 use std::unit_test::assert_eq;
 
 // ===== Constants =====

packages/deeptrade-core/tests/plans/get_deep_plan.move

@@ -1,7 +1,7 @@
 #[test_only]
 module deeptrade_core::get_deep_plan_tests;
 
-use deeptrade_core::order::{get_deep_plan, assert_deep_plan_eq};
+use deeptrade_core::dt_order::{get_deep_plan, assert_deep_plan_eq};
 
 // -------------------------------------
 // Constants for realistic DEEP amounts