ksxt 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

ksxt/models/balance.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 from typing import List
 
 from ksxt.models.common import GeneralResponse
@@ -7,14 +7,27 @@ from ksxt.models.common import GeneralResponse
 class BalanceData(BaseModel):
     symbol: str
     name: str
-    evaluation_price: float
+
     price: float
-    pnl_amount: float
-    pnl_ratio: float
+    evaluation_price: float
+
     qty: float
     free_qty: float
     used_qty: float
 
+    amount: float | None = 0.0
+    evaluation_amount: float | None = 0.0
+    pnl: float | None = 0.0
+    pnl_ratio: float | None = 0.0
+
+    @model_validator(mode="after")
+    def calculate_fields(cls, values):
+        values.amount = values.price * values.qty
+        values.evaluation_amount = values.evaluation_price * values.qty
+        values.pnl = values.evaluation_price - values.price
+        values.pnl_ratio = values.pnl / values.price if values.price != 0 else 0.0
+        return values
+
 
 class BalanceInfo(BaseModel):
     currency: str

ksxt/models/transaction.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import List
 from pydantic import BaseModel
 
 from ksxt.models.common import GeneralResponse
@@ -8,43 +8,37 @@ from ksxt.models.common import GeneralResponse
 class TransactionInfo(BaseModel):
     # 주문 고유 아이디
     uuid: str
-    # 주문 종류 (ask, bid, deposit, withdrawal)
-    type: str
-
-    # 금액
-    amount: float
-    # 수수료
-    fee: Optional[float] = 0
-
     # 계좌 번호
-    account_id: Optional[str] = None
-    # 화폐 통화 정보
-    currency: Optional[str] = None
+    account_id: str | None = None
 
-    # 주문 생성 시간
-    created_at: datetime
+    # 주문 종류 (ask, bid, deposit, withdrawal)
+    transaction_type: str
 
+    # order type (limit, market, default)
+    order_type: str | None = None
+
+    # position (long, short)
+    tr_position: str | None = None
 
-class OpenedOrderInfo(TransactionInfo):
     # 종목 정보
     symbol: str
     # 가격
     price: float
     # 수량
     qty: float
-    # 주문 방식
-    order_type: Optional[str]
+    # 금액
+    amount: float
 
+    # 세금
+    tax: float | None = 0
+    # 수수료
+    fee: float | None = 0
 
-class ClosedOrderInfo(TransactionInfo):
-    # 종목 정보
-    symbol: str
-    # 가격
-    price: float
-    # 수량
-    qty: float
-    # 주문 방식
-    order_type: Optional[str]
+    # 화폐 통화 정보
+    currency: str | None = None
+
+    # 주문 생성 시간
+    created_at: datetime
 
 
 class WithdrawalHistory(BaseModel):
@@ -56,11 +50,11 @@ class DepositHistory(BaseModel):
 
 
 class OpenedOrderHistory(BaseModel):
-    history: List[OpenedOrderInfo]
+    history: List[TransactionInfo]
 
 
 class ClosedOrderHistory(BaseModel):
-    history: List[ClosedOrderInfo]
+    history: List[TransactionInfo]
 
 
 class KsxtWithdrawalHistoryResponse(GeneralResponse[WithdrawalHistory]):

ksxt/parser/bithumb.py

@@ -1,13 +1,10 @@
-from datetime import datetime
-from operator import attrgetter
+from datetime import datetime, timezone
 from typing import Dict, List, Optional
 
 from ksxt.models.transaction import (
     ClosedOrderHistory,
-    ClosedOrderInfo,
     DepositHistory,
     OpenedOrderHistory,
-    OpenedOrderInfo,
     TransactionInfo,
     WithdrawalHistory,
 )
@@ -24,6 +21,10 @@ from ksxt.utils import safer, sorter
 
 class BithumbParser(BaseParser):
     def safe_symbol(self, base_market: str, security: str) -> str:
+        # If security already contains a hyphen, assume it's correctly formatted
+        if "-" in security:
+            return security
+
         return f"{base_market}-{security}"
 
     def parse_markets(self, response: List[Dict], base_market: str = "KRW") -> MarketInfo:
@@ -46,8 +47,22 @@ class BithumbParser(BaseParser):
             warning_code=False if safer.safe_string(market, "market_warning") == "NONE" else True,
         )
 
-    def parse_historical_data(self, response: dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         ohlcv = [self._parse_ohlcva(_, base_market) for _ in response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -161,7 +176,13 @@ class BithumbParser(BaseParser):
         return ask_data, bid_data
 
     def parse_balance(
-        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+        self,
+        response: List[Dict],
+        base_market: str = "KRW",
+        excluded_symbols: Optional[list[str]] = None,
+        included_symbols: Optional[list[str]] = None,
+        filter_delisted: bool = True,
+        min_amount: float = 0,
     ) -> BalanceInfo:
         # 1. Filter out entries where 'currency' is not the base_market
         # 2. Ensure 'unit_currency' is the base_market
@@ -172,11 +193,18 @@ class BithumbParser(BaseParser):
             if data["currency"] != base_market
             and data["unit_currency"] == base_market
             and (excluded_symbols is None or data["currency"] not in excluded_symbols)
+            and (included_symbols is None or self.safe_symbol(base_market, data["currency"]) in included_symbols)
         ]
 
         # Initialize balance list
         balances = [self._parse_balance(data, base_market) for data in filtered_data]
 
+        if filter_delisted:
+            balances = [balance for balance in balances if balance.price > 0]
+
+        if min_amount > 0:
+            balances = [balance for balance in balances if balance.amount > min_amount]
+
         # 총 매입금액
         total_amount = sum(bal.price * bal.qty for bal in balances)
         total_evaluation_amount = sum(bal.evaluation_price * bal.qty for bal in balances)
@@ -198,8 +226,6 @@ class BithumbParser(BaseParser):
             name=self.safe_symbol(base_market, safer.safe_string(data, "currency")),
             evaluation_price=0,  # 필요에 따라 적절히 설정
             price=safer.safe_number(data, "avg_buy_price"),
-            pnl_amount=0,  # 필요에 따라 적절히 설정
-            pnl_ratio=0,  # 필요에 따라 적절히 설정
             qty=safer.safe_number(data, "balance"),
             free_qty=safer.safe_number(data, "balance") - safer.safe_number(data, "locked"),
             used_qty=safer.safe_number(data, "locked"),
@@ -256,38 +282,72 @@ class BithumbParser(BaseParser):
             market_ask_fee=safer.safe_number(response, "maker_ask_fee"),
         )
 
-    def parse_open_order_history(self, response: dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         orders = [self._parse_open_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return OpenedOrderHistory(history=orders)
 
-    def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> OpenedOrderInfo:
-        return OpenedOrderInfo(
+    def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> TransactionInfo:
+        return TransactionInfo(
             uuid=safer.safe_string(order, "uuid"),
-            type=safer.safe_string(order, "side"),
+            account_id="",
+            transaction_type=safer.safe_string(order, "side"),
+            order_type=safer.safe_string(order, "ord_type"),
+            tr_position="long",
             symbol=self.safe_symbol(base_market, safer.safe_string(order, "market")),
             price=safer.safe_number(order, "price"),
             qty=safer.safe_number(order, "volume"),
             amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            tax=0,
             fee=safer.safe_number(order, "reserved_fee"),
+            currency=base_market,
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
-            order_type=safer.safe_string(order, "ord_type"),
         )
 
-    def parse_closed_order_history(self, response: dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         orders = [self._parse_closed_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return ClosedOrderHistory(history=orders)
 
-    def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> ClosedOrderInfo:
-        return ClosedOrderInfo(
+    def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> TransactionInfo:
+        return TransactionInfo(
             uuid=safer.safe_string(order, "uuid"),
-            type=safer.safe_string(order, "side"),
-            symbol=safer.safe_string(order, "market"),
+            account_id="",
+            transaction_type=safer.safe_string(order, "side"),
+            order_type=safer.safe_string(order, "ord_type"),
+            tr_position="long",
+            symbol=self.safe_symbol(base_market, safer.safe_string(order, "market")),
             price=safer.safe_number(order, "price"),
             qty=safer.safe_number(order, "volume"),
             amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            tax=0,
             fee=safer.safe_number(order, "reserved_fee"),
+            currency=base_market,
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
-            order_type=safer.safe_string(order, "ord_type"),
         )
 
     def parse_cancel_order(self, response: dict, base_market: str = "KRW") -> CancelOrderResponse:
@@ -296,20 +356,61 @@ class BithumbParser(BaseParser):
     def parse_create_order(self, response: dict, base_market: str = "KRW") -> CreateOrderResponse:
         return CreateOrderResponse(order_datetime=datetime.now(), order_id=safer.safe_string(response, "uuid"))
 
-    def parse_withdrawal_history(self, response: List[Dict], base_market: str = "KRW") -> WithdrawalHistory:
+    def parse_withdrawal_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> WithdrawalHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return WithdrawalHistory(history=parsed_items)
 
-    def parse_deposit_history(self, response: List[Dict], base_market: str = "KRW") -> DepositHistory:
+    def parse_deposit_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> DepositHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return DepositHistory(history=parsed_items)
 
     def _parse_transaction_history_item(self, item: Dict, base_market: str = "KRW") -> TransactionInfo:
         return TransactionInfo(
             uuid=safer.safe_string(item, "uuid"),
-            type=safer.safe_string(item, "type"),
+            account_id="",
+            transaction_type=safer.safe_string(item, "type"),
+            order_type=safer.safe_string(item, "transaction_type"),
+            tr_position="",
+            symbol=safer.safe_string(item, "currency"),
+            price=1,
+            qty=safer.safe_number(item, "amount"),
             amount=safer.safe_number(item, "amount"),
+            tax=0,
             fee=safer.safe_number(item, "fee"),
             currency=safer.safe_string(item, "currency"),
-            created_at=datetime.fromisoformat(safer.safe_string(item, "created_at")),
+            created_at=datetime.fromisoformat(safer.safe_string(item, "done_at")),
         )

ksxt/parser/koreainvest.py

@@ -11,10 +11,9 @@ from ksxt.models.ticker import MultiSymbolTickerInfo, TickerInfo
 from ksxt.models.token import TokenInfo
 from ksxt.models.transaction import (
     ClosedOrderHistory,
-    ClosedOrderInfo,
     DepositHistory,
     OpenedOrderHistory,
-    OpenedOrderInfo,
+    TransactionInfo,
 )
 from ksxt.parser.parser import BaseParser
 from ksxt.utils import safer, sorter, timer
@@ -52,9 +51,23 @@ class KoreaInvestParser(BaseParser):
             warning_code=safer.safe_boolean(market, " market_warning"),
         )
 
-    def parse_historical_data(self, response: Dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         safe_response = safer.safe_value(response, "output2")
         ohlcv = [self._parse_ohlcva(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -77,9 +90,23 @@ class KoreaInvestParser(BaseParser):
             acml_amount=safer.safe_number(ohlcva, "acml_tr_pbmn"),
         )
 
-    def parse_historical_index_data(self, response: Dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_index_data(
+        self,
+        response: Dict,
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         safe_response = safer.safe_value(response, "output2")
         ohlcv = [self._parse_index_ohlcva(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -154,7 +181,13 @@ class KoreaInvestParser(BaseParser):
         return ask_data, bid_data
 
     def parse_balance(
-        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+        self,
+        response: List[Dict],
+        base_market: str = "KRW",
+        excluded_symbols: Optional[list[str]] = None,
+        included_symbols: list[str] | None = None,
+        filter_delisted: bool = True,
+        min_amount: float = 0,
     ) -> BalanceInfo:
         safe_response = safer.safe_value(response, "output1")
 
@@ -162,9 +195,16 @@ class KoreaInvestParser(BaseParser):
         balances = [
             self._parse_balance(_, base_market)
             for _ in safe_response
-            if excluded_symbols is None or safer.safe_string(_, "pdno") not in excluded_symbols
+            if (excluded_symbols is None or safer.safe_string(_, "pdno") not in excluded_symbols)
+            and (included_symbols is None or safer.safe_string(_, "pdno") in included_symbols)
         ]
 
+        if filter_delisted:
+            balances = [balance for balance in balances if balance.price > 0]
+
+        if min_amount > 0:
+            balances = [balance for balance in balances if balance.amount > min_amount]
+
         # 총 매입금액
         total_amount = sum(bal.price * bal.qty for bal in balances)
         total_evaluation_amount = sum(bal.evaluation_price * bal.qty for bal in balances)
@@ -186,7 +226,7 @@ class KoreaInvestParser(BaseParser):
             name=safer.safe_string(data, "prdt_name"),
             evaluation_price=safer.safe_number(data, "evlu_amt"),
             price=safer.safe_number(data, "pchs_avg_pric"),
-            pnl_amount=safer.safe_number(data, "evlu_pfls_amt"),
+            pnl=safer.safe_number(data, "evlu_pfls_amt"),
             pnl_ratio=safer.safe_number(data, "evlu_pfls_rt"),
             qty=safer.safe_number(data, "hldg_qty"),
             free_qty=safer.safe_number(data, "ord_psbl_qty"),
@@ -242,52 +282,75 @@ class KoreaInvestParser(BaseParser):
             market_ask_fee=0.0140527 + trading_fee,
         )
 
-    def parse_closed_order_history(self, response: Dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         safe_response = safer.safe_value(response, "output1")
-        history = [self._parse_closed_order_info(_, base_market) for _ in safe_response]
-        return ClosedOrderHistory(history=history)
+        orders = [self._parse_closed_order_info(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [order for order in orders if order.created_at >= start]
+        if end:
+            orders = [order for order in orders if order.created_at <= end]
+
+        return ClosedOrderHistory(history=orders)
 
-    def _parse_closed_order_info(self, order: Dict, base_market: str = "KRW") -> ClosedOrderInfo:
+    def _parse_closed_order_info(self, order: Dict, base_market: str = "KRW") -> TransactionInfo:
         if safer.safe_string(order, "sll_buy_dvsn_cd") == "01":
             _type = "ask"
         else:
             _type = "bid"
 
-        return ClosedOrderInfo(
+        return TransactionInfo(
             uuid=safer.safe_string(order, "odno"),
-            type=_type,
+            account_id="",
+            # account_id=f'{safer.safe_string(order, "CANO")}-{safer.safe_string(order, "ACNT_PRDT_CD")}',
+            transaction_type=_type,
             symbol=safer.safe_string(order, "pdno"),
             price=safer.safe_number(order, "avg_prvs"),
             qty=safer.safe_number(order, "tot_ccld_qty"),
             amount=safer.safe_number(order, "tot_ccld_amt"),
+            tax=0,
             # 단일 주문 이력에는 수수료 관련 정보가 없고, 조회한 전체 목록에 대해 수수료 정보만 존재한다.
             fee=0,
-            created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),
             order_type=safer.safe_string(order, "avg_prvs"),
+            created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),
         )
 
-    def parse_open_order_history(self, response: Dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         safe_response = safer.safe_value(response, "output1")
-        history = [self._parse_open_order_info(_, base_market) for _ in safe_response]
-        return OpenedOrderHistory(history=history)
+        orders = [self._parse_open_order_info(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [order for order in orders if order.created_at >= start]
+        if end:
+            orders = [order for order in orders if order.created_at <= end]
+
+        return OpenedOrderHistory(history=orders)
 
-    def _parse_open_order_info(self, order: Dict, base_market: str = "KRW") -> OpenedOrderInfo:
+    def _parse_open_order_info(self, order: Dict, base_market: str = "KRW") -> TransactionInfo:
         if safer.safe_string(order, "sll_buy_dvsn_cd") == "01":
             _type = "ask"
         else:
             _type = "bid"
 
-        return OpenedOrderInfo(
+        return TransactionInfo(
             uuid=safer.safe_string(order, "odno"),
-            type=_type,
+            transaction_type=_type,
             symbol=safer.safe_string(order, "pdno"),
             price=safer.safe_number(order, "avg_prvs"),
             qty=safer.safe_number(order, "tot_ccld_qty"),
             amount=safer.safe_number(order, "tot_ccld_amt"),
+            tax=0,
             # 단일 주문 이력에는 수수료 관련 정보가 없고, 조회한 전체 목록에 대해 수수료 정보만 존재한다.
             fee=0,
-            created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),
+            currency=base_market,
             order_type=safer.safe_string(order, "avg_prvs"),
+            created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),
         )
 
     def parse_create_order(self, response: Dict, base_market: str = "KRW") -> CreateOrderResponse:

ksxt/parser/parser.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Dict, List, Optional
 import inspect
 
@@ -10,10 +11,8 @@ from ksxt.models.orderbook import MultiSymbolOrderBookInfos, OrderBookData, Orde
 from ksxt.models.ticker import MultiSymbolTickerInfo, TickerInfo
 from ksxt.models.transaction import (
     ClosedOrderHistory,
-    ClosedOrderInfo,
     DepositHistory,
     OpenedOrderHistory,
-    OpenedOrderInfo,
     TransactionInfo,
     WithdrawalHistory,
 )
@@ -30,7 +29,14 @@ class BaseParser:
     def _parse_market(self, market: Dict) -> SecurityData:
         self._raise_not_implemented_error()
 
-    def parse_historical_data(self, response: dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         self._raise_not_implemented_error()
 
     def _parse_ohlcva(self, ohlcva: dict, base_market: str = "KRW") -> OHLCVData:
@@ -63,7 +69,13 @@ class BaseParser:
         self._raise_not_implemented_error()
 
     def parse_balance(
-        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+        self,
+        response: List[Dict],
+        base_market: str = "KRW",
+        excluded_symbols: Optional[list[str]] = None,
+        included_symbols: list[str] | None = None,
+        filter_delisted: bool = True,
+        min_amount: float = 0,
     ) -> BalanceInfo:
         self._raise_not_implemented_error()
 
@@ -79,16 +91,20 @@ class BaseParser:
     def parse_trade_fee(self, response: dict, base_market: str = "KRW") -> TradeFeeInfo:
         self._raise_not_implemented_error()
 
-    def parse_open_order_history(self, response: dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         self._raise_not_implemented_error()
 
-    def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> OpenedOrderInfo:
+    def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> TransactionInfo:
         self._raise_not_implemented_error()
 
-    def parse_closed_order_history(self, response: dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         self._raise_not_implemented_error()
 
-    def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> ClosedOrderInfo:
+    def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> TransactionInfo:
         self._raise_not_implemented_error()
 
     def parse_modify_order(self, response: dict, base_market: str = "KRW") -> ModifyOrderResponse:
@@ -100,10 +116,14 @@ class BaseParser:
     def parse_create_order(self, response: dict, base_market: str = "KRW") -> CreateOrderResponse:
         self._raise_not_implemented_error()
 
-    def parse_withdrawal_history(self, response: List[Dict], base_market: str = "KRW") -> WithdrawalHistory:
+    def parse_withdrawal_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> WithdrawalHistory:
         self._raise_not_implemented_error()
 
-    def parse_deposit_history(self, response: List[Dict], base_market: str = "KRW") -> DepositHistory:
+    def parse_deposit_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> DepositHistory:
         self._raise_not_implemented_error()
 
     def _parse_transaction_history_item(self, item: Dict, base_market: str = "KRW") -> TransactionInfo: