NautilusTrader SDK

1#!/usr/bin/env python3
2# -------------------------------------------------------------------------------------------------
3#  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
4#  https://nautechsystems.io
5#
6#  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
7#  You may not use this file except in compliance with the License.
8#  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
9#
10#  Unless required by applicable law or agreed to in writing, software
11#  distributed under the License is distributed on an "AS IS" BASIS,
12#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13#  See the License for the specific language governing permissions and
14#  limitations under the License.
15# -------------------------------------------------------------------------------------------------
16 
17import asyncio
18import json
19from decimal import Decimal
20 
21from nautilus_trader.adapters.binance.common.enums import BinanceAccountType
22from nautilus_trader.adapters.binance.common.enums import BinanceEnvironment
23from nautilus_trader.adapters.binance.config import BinanceDataClientConfig
24from nautilus_trader.adapters.binance.factories import BinanceLiveDataClientFactory
25from nautilus_trader.adapters.binance.futures.types import BinanceFuturesMarkPriceUpdate
26from nautilus_trader.adapters.sandbox.config import SandboxExecutionClientConfig
27from nautilus_trader.adapters.sandbox.factory import SandboxLiveExecClientFactory
28from nautilus_trader.common.enums import LogColor
29from nautilus_trader.config import CacheConfig
30from nautilus_trader.config import InstrumentProviderConfig
31from nautilus_trader.config import LiveExecEngineConfig
32from nautilus_trader.config import LoggingConfig
33from nautilus_trader.config import TradingNodeConfig
34from nautilus_trader.core.data import Data
35from nautilus_trader.live.node import TradingNode
36from nautilus_trader.model.data import Bar
37from nautilus_trader.model.data import DataType
38from nautilus_trader.model.data import QuoteTick
39from nautilus_trader.model.data import TradeTick
40from nautilus_trader.model.identifiers import ClientId
41from nautilus_trader.model.identifiers import InstrumentId
42from nautilus_trader.model.identifiers import TraderId
43from nautilus_trader.model.identifiers import Venue
44from nautilus_trader.model.instruments import Instrument
45from nautilus_trader.trading import Strategy
46from nautilus_trader.trading.config import StrategyConfig
47 
48 
49# *** THIS IS A TEST STRATEGY WITH NO ALPHA ADVANTAGE WHATSOEVER. ***
50# *** IT IS NOT INTENDED TO BE USED TO TRADE LIVE WITH REAL MONEY. ***
51 
52 
53class TestStrategyConfig(StrategyConfig, frozen=True):
54    futures_client_id: ClientId
55    futures_instrument_id: InstrumentId
56    spot_instrument_id: InstrumentId
57 
58 
59class TestStrategy(Strategy):
60    def __init__(self, config: TestStrategyConfig) -> None:
61        super().__init__(config)
62 
63        self.futures_instrument: Instrument | None = None  # Initialized in on_start
64        self.spot_instrument: Instrument | None = None  # Initialized in on_start
65        self.futures_client_id = config.futures_client_id
66 
67    def on_start(self) -> None:
68        self.futures_instrument = self.cache.instrument(self.config.futures_instrument_id)
69        if self.futures_instrument is None:
70            self.log.error(
71                f"Could not find instrument for {self.config.futures_instrument_id}"
72                f"\nPossible instruments: {self.cache.instrument_ids()}",
73            )
74            self.stop()
75            return
76        self.spot_instrument = self.cache.instrument(self.config.spot_instrument_id)
77        if self.spot_instrument is None:
78            self.log.error(
79                f"Could not find futures instrument for {self.config.spot_instrument_id}"
80                f"\nPossible instruments: {self.cache.instrument_ids()}",
81            )
82            self.stop()
83            return
84 
85        account = self.portfolio.account(venue=self.futures_instrument.venue)
86        balances = {str(currency): str(balance) for currency, balance in account.balances().items()}
87        self.log.info(f"Futures balances\n{json.dumps(balances, indent=4)}", LogColor.GREEN)
88        account = self.portfolio.account(venue=self.spot_instrument.venue)
89        balances = {str(currency): str(balance) for currency, balance in account.balances().items()}
90        self.log.info(f"Spot balances\n{json.dumps(balances, indent=4)}", LogColor.GREEN)
91 
92        # Subscribe to live data
93        self.subscribe_quote_ticks(self.config.futures_instrument_id)
94        self.subscribe_quote_ticks(self.config.spot_instrument_id)
95        self.subscribe_data(
96            data_type=DataType(
97                BinanceFuturesMarkPriceUpdate,
98                metadata={"instrument_id": self.futures_instrument.id},
99            ),
100            client_id=self.futures_client_id,
101        )
102 
103    def on_data(self, data: Data) -> None:
104        self.log.info(repr(data), LogColor.CYAN)
105 
106    def on_quote_tick(self, tick: QuoteTick) -> None:
107        self.log.info(repr(tick), LogColor.CYAN)
108 
109    def on_trade_tick(self, tick: TradeTick) -> None:
110        self.log.info(repr(tick), LogColor.CYAN)
111 
112    def on_bar(self, bar: Bar) -> None:
113        self.log.info(repr(bar), LogColor.CYAN)
114 
115    def on_stop(self) -> None:
116        # Unsubscribe from data
117        self.unsubscribe_quote_ticks(self.config.futures_instrument_id)
118        self.unsubscribe_quote_ticks(self.config.spot_instrument_id)
119 
120 
121async def main():
122    """
123    Show how to run a strategy in a sandbox for the Binance venue.
124    """
125    # Configure the trading node
126    config_node = TradingNodeConfig(
127        trader_id=TraderId("TESTER-001"),
128        logging=LoggingConfig(
129            log_level="INFO",
130            log_colors=True,
131            use_pyo3=True,
132        ),
133        exec_engine=LiveExecEngineConfig(
134            reconciliation=True,
135            reconciliation_lookback_mins=1440,
136            filter_position_reports=True,
137        ),
138        cache=CacheConfig(
139            timestamps_as_iso8601=True,
140            flush_on_start=False,
141        ),
142        data_clients={
143            "BINANCE_FUTURES": BinanceDataClientConfig(
144                venue=Venue("BINANCE_FUTURES"),
145                account_type=BinanceAccountType.USDT_FUTURES,
146                base_url_http=None,  # Override with custom endpoint
147                base_url_ws=None,  # Override with custom endpoint
148                environment=BinanceEnvironment.LIVE,
149                us=False,  # If client is for Binance US
150                instrument_provider=InstrumentProviderConfig(load_all=True),
151            ),
152            "BINANCE_SPOT": BinanceDataClientConfig(
153                venue=Venue("BINANCE_SPOT"),
154                account_type=BinanceAccountType.SPOT,
155                base_url_http=None,  # Override with custom endpoint
156                base_url_ws=None,  # Override with custom endpoint
157                environment=BinanceEnvironment.LIVE,
158                us=False,  # If client is for Binance US
159                instrument_provider=InstrumentProviderConfig(load_all=True),
160            ),
161        },
162        exec_clients={
163            "BINANCE_FUTURES": SandboxExecutionClientConfig(
164                venue="BINANCE_FUTURES",
165                account_type="MARGIN",
166                starting_balances=["10_000 USDC", "0.005 BTC"],
167                default_leverage=Decimal(5),
168            ),
169            "BINANCE_SPOT": SandboxExecutionClientConfig(
170                venue="BINANCE_SPOT",
171                account_type="CASH",
172                starting_balances=["1_000 USDC", "0.001 BTC"],
173            ),
174        },
175        timeout_connection=30.0,
176        timeout_reconciliation=10.0,
177        timeout_portfolio=10.0,
178        timeout_disconnection=10.0,
179        timeout_post_stop=5.0,
180    )
181 
182    # Instantiate the node with a configuration
183    node = TradingNode(config=config_node)
184 
185    # Configure your strategy
186    strat_config = TestStrategyConfig(
187        futures_client_id=ClientId("BINANCE_FUTURES"),
188        futures_instrument_id=InstrumentId.from_str("BTCUSDT-PERP.BINANCE_FUTURES"),
189        spot_instrument_id=InstrumentId.from_str("BTCUSDC.BINANCE_SPOT"),
190    )
191    # Instantiate your strategy
192    strategy = TestStrategy(config=strat_config)
193 
194    # Add your strategies and modules
195    node.trader.add_strategy(strategy)
196 
197    # Register your client factories with the node (can take user-defined factories)
198    node.add_data_client_factory("BINANCE_FUTURES", BinanceLiveDataClientFactory)
199    node.add_data_client_factory("BINANCE_SPOT", BinanceLiveDataClientFactory)
200    node.add_exec_client_factory("BINANCE_FUTURES", SandboxLiveExecClientFactory)
201    node.add_exec_client_factory("BINANCE_SPOT", SandboxLiveExecClientFactory)
202    node.build()
203 
204    try:
205        await node.run_async()
206    finally:
207        await node.stop_async()
208        await asyncio.sleep(1)
209        node.dispose()
210 
211 
212# Stop and dispose of the node with SIGINT/CTRL+C
213if __name__ == "__main__":
214    asyncio.run(main())
215