Martingale42/nautilus-dev / skills/nt-trading
nt-trading
VerifiedUse when working with strategy logic, order execution, risk management, position/portfolio tracking, or exec algorithms in NautilusTrader.
references/guides/write_rust_strategy.md
View on GitHub# Write a Strategy (Rust)
A strategy extends an actor with order management. This guide walks through
building a minimal strategy that subscribes to quotes and submits market
orders. Read [Write an Actor (Rust)](write_rust_actor.md) first.
For background on strategy concepts and order management, see the
[Strategies](../concepts/strategies.md) and [Rust](../concepts/rust.md)
concept guides.
## Define the struct
A strategy owns a `StrategyCore` instead of a `DataActorCore`. The
`StrategyCore` wraps `DataActorCore` and adds an `OrderFactory`,
`OrderManager`, and portfolio integration.
```rust
use nautilus_common::actor::DataActor;
use nautilus_model::{
data::QuoteTick,
enums::OrderSide,
identifiers::{InstrumentId, StrategyId},
types::Quantity,
};
use nautilus_trading::{nautilus_strategy, strategy::{Strategy, StrategyConfig, StrategyCore}};
pub struct MyStrategy {
core: StrategyCore,
instrument_id: InstrumentId,
trade_size: Quantity,
}
```
## Implement the constructor
`StrategyConfig` takes a `strategy_id` and an `order_id_tag`. The tag is
appended to all client order IDs from this strategy, preventing collisions
when multiple strategies trade the same instrument.
```rust
impl MyStrategy {
pub fn new(instrument_id: InstrumentId) -> Self {
let config = StrategyConfig {
strategy_id: Some(StrategyId::from("MY_STRAT-001")),
order_id_tag: Some("001".to_string()),
..Default::default()
};
Self {
core: StrategyCore::new(config),
instrument_id,
trade_size: Quantity::from("1.0"),
}
}
}
```
## Wire up the core and implement Debug
The `nautilus_strategy!` macro generates `Deref<Target = DataActorCore>`,
`DerefMut`, and the `Strategy` trait impl (the `core()`/`core_mut()`
accessors). By default it delegates to a field named `core`; pass a second
argument for a different field name.
`Debug` is a trait bound on `DataActor`, so implement it manually or derive
it.
```rust
nautilus_strategy!(MyStrategy);
impl std::fmt::Debug for MyStrategy {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MyStrategy").finish()
}
}
```
## Implement the DataActor trait
Data handling works the same as in an actor. Subscribe in `on_start`,
respond in handlers.
```rust
impl DataActor for MyStrategy {
fn on_start(&mut self) -> anyhow::Result<()> {
self.subscribe_quotes(self.instrument_id, None, None);
Ok(())
}
fn on_quote(&mut self, quote: &QuoteTick) -> anyhow::Result<()> {
let order = self.core.order_factory().market(
self.instrument_id,
OrderSide::Buy,
self.trade_size,
None, None, None, None, None, None, None,
);
self.submit_order(order, None, None)?;
Ok(())
}
}
```
`self.core.order_factory()` builds order objects. Available methods:
`market`, `limit`, `stop_market`, `stop_limit`, `market_if_touched`,
`limit_if_touched`, and `trailing_stop_market`.
`submit_order` is available on `self` through the `Strategy` trait impl
generated by the macro.
## Override Strategy hooks
To override `Strategy` trait methods such as order or position event
handlers, pass them in a block. The macro generates `core()` and
`core_mut()` automatically; do not redefine them in the block.
```rust
nautilus_strategy!(MyStrategy, {
fn on_order_rejected(&mut self, event: OrderRejected) {
log::warn!("Order rejected: {}", event.reason);
}
});
```
## Order management methods
The `Strategy` trait provides these methods through `StrategyCore`:
| Method | Action |
|-----------------------|-------------------------------------------|
| `submit_order` | Submit a new order to the venue. |
| `submit_order_list` | Submit a list of contingent orders. |
| `modify_order` | Modify price, quantity, or trigger price. |
| `cancel_order` | Cancel a specific order. |
| `cancel_orders` | Cancel a filtered set of orders. |
| `cancel_all_orders` | Cancel all orders for an instrument. |
| `close_position` | Close a position with a market order. |
| `close_all_positions` | Close all open positions. |
## Full examples
- [`EmaCross`](https://github.com/nautechsystems/nautilus_trader/tree/develop/crates/trading/src/examples/strategies/ema_cross):
Dual-EMA crossover with indicator integration.
- [`GridMarketMaker`](https://github.com/nautechsystems/nautilus_trader/tree/develop/crates/trading/src/examples/strategies/grid_mm):
Grid market making with configurable levels and requoting.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |