synpath 0.1.0__py3-none-any.whl

synpath/engine/orders/manager.py

@@ -0,0 +1,223 @@
+"""The supervisor: every engine-held order, and what reaches it.
+
+One `ManagedOrders` per engine. It creates parents, hands them the events
+they asked for, writes their state down whenever it changes, and brings them
+back after a restart. Three details are worth stating, because they are what
+makes an engine-held order safe rather than a background task:
+
+**Every change is persisted before the next one.** A stop that has just
+triggered is written as triggered before its child is sent, so a crash in
+between leaves a parent whose child is in doubt, which the engine's own
+recovery already knows how to resolve.
+
+**Events are routed, not broadcast.** A parent hears about its own children
+and about the instruments it named. A thousand resting parents on other
+markets cost nothing when a book ticks.
+
+**One bad parent does not stop the rest.** A hook that raises is logged, the
+parent is marked rejected with the reason, and every other parent carries on.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from decimal import Decimal
+from typing import Any, Iterable, Mapping, Type
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType
+from .base import Child, Context, ManagedOrder, State, now_ms
+
+log = logging.getLogger("synpath.engine.orders")
+
+REGISTRY: dict[str, Type[ManagedOrder]] = {}
+
+
+def register(cls: Type[ManagedOrder]) -> Type[ManagedOrder]:
+    """Make a managed order type known to `submit` and to recovery."""
+    REGISTRY[cls.kind] = cls
+    return cls
+
+
+class ManagedOrders:
+    """Every engine-held order this engine is running."""
+
+    def __init__(self, engine: Any):
+        self.engine = engine
+        self.parents: dict[str, ManagedOrder] = {}
+        self.by_child: dict[str, str] = {}
+        """Child order id to parent id."""
+        self.by_market: dict[str, set[str]] = {}
+
+    # -- lookup ---------------------------------------------------------------
+
+    def live(self) -> list[ManagedOrder]:
+        return [p for p in self.parents.values() if p.live]
+
+    def get(self, parent_id: str) -> ManagedOrder | None:
+        return self.parents.get(parent_id)
+
+    def parent_of(self, order_id: str, venue: str | None = None) -> ManagedOrder | None:
+        parent_id = (self.by_child.get(f"{venue}:{order_id}") if venue else None) or self.by_child.get(order_id)
+        return self.parents.get(parent_id) if parent_id else None
+
+    def adopt_child(self, parent_id: str, order_id: str, venue: str | None = None) -> None:
+        self.by_child[order_id] = parent_id
+        if venue:
+            self.by_child[f"{venue}:{order_id}"] = parent_id
+
+    def context(self, parent: ManagedOrder) -> Context:
+        return Context(self.engine, parent)
+
+    def watching(self, market_id: str) -> list[ManagedOrder]:
+        return [self.parents[pid] for pid in self.by_market.get(market_id, set())
+                if pid in self.parents and self.parents[pid].live]
+
+    # -- creating -------------------------------------------------------------
+
+    def build(self, request: OrderRequest, *, venue: str, account: Any) -> ManagedOrder:
+        # `managed_kind` lets one venue type map to an engine-held variant:
+        # a market order the engine walks the book with, rather than the
+        # adapter's single immediate limit.
+        kind = str(request.params.get("managed_kind") or request.type.value)
+        cls = REGISTRY.get(kind)
+        if cls is None:
+            raise NotImplementedError(
+                f"{kind} is an engine-held order type with no implementation loaded; "
+                f"known: {sorted(REGISTRY)}"
+            )
+        return cls(request, venue=venue, account=account)
+
+    async def create(self, request: OrderRequest, *, venue: str, account: Any, owner: ManagedOrder | None = None) -> ManagedOrder:
+        parent = self.build(request, venue=venue, account=account)
+        parent.owner_id = owner.id if owner else None
+        self.remember(parent)
+        if owner is not None:
+            self.by_child[parent.id] = owner.id
+        await self.save(parent)
+        await self.engine.bus.publish("managed.created", {
+            "parent_id": parent.id, "kind": parent.kind, "market_id": parent.market_id,
+            "side": parent.side.value, "amount": str(parent.amount), "book": request.book,
+        }, key=parent.id)
+        await self.run(parent, lambda ctx: parent.start(ctx))
+        return parent
+
+    def remember(self, parent: ManagedOrder) -> None:
+        self.parents[parent.id] = parent
+        for instrument in parent.markets():
+            self.by_market.setdefault(instrument, set()).add(parent.id)
+        for child in parent.children:
+            self.adopt_child(parent.id, child.order_id, child.venue)
+
+    def forget(self, parent: ManagedOrder) -> None:
+        for instrument in parent.markets():
+            self.by_market.get(instrument, set()).discard(parent.id)
+
+    # -- routing --------------------------------------------------------------
+
+    async def run(self, parent: ManagedOrder, call: Any) -> None:
+        """Run one hook, catching what it raises so the others keep working."""
+        ctx = self.context(parent)
+        try:
+            await call(ctx)
+        except Exception as exc:
+            log.exception("synpath.engine.orders: %s %s failed", parent.kind, parent.id)
+            parent.detail = f"{type(exc).__name__}: {exc}"
+            try:
+                await parent.finish(ctx, "rejected", parent.detail)
+            except Exception:  # pragma: no cover - the journal is the only thing left
+                log.exception("synpath.engine.orders: could not record the failure of %s", parent.id)
+        finally:
+            if not parent.live:
+                self.forget(parent)
+            await self.save(parent)
+            if not parent.live and parent.owner_id:
+                await self.tell_owner(parent)
+
+    async def tell_owner(self, leg: ManagedOrder) -> None:
+        """A leg of a bracket or an OCO ended: its owner decides what that means."""
+        owner = self.parents.get(leg.owner_id or "")
+        if owner is None or not owner.live:
+            return
+        child = owner.child_of(leg.id)
+        if child is None:
+            return
+        child.status = leg.state
+        child.filled = leg.filled
+        await self.run(owner, lambda ctx: owner.on_child(ctx, leg.as_order(), child))
+
+    async def on_book(self, market_id: str) -> None:
+        for parent in self.watching(market_id):
+            await self.run(parent, lambda ctx, p=parent: p.on_book(ctx, market_id))
+
+    async def on_trade(self, market_id: str, price: Decimal, amount: Decimal) -> None:
+        for parent in self.watching(market_id):
+            await self.run(parent, lambda ctx, p=parent: p.on_trade(ctx, market_id, price, amount))
+
+    async def on_order(self, order: Order) -> None:
+        """The venue's record of a child changed. This is the one channel a
+        parent learns its children's fills from: the record is a snapshot,
+        the latest overwrites, and the progress since the last one drives
+        `on_fill`. Fill events are the ledger's and never reach a parent."""
+        parent = self.parent_of(order.id, order.venue)
+        if parent is None:
+            return
+        child = parent.child_of(order.id, order.venue)
+        if child is None:
+            return
+        progress = parent.note_order(order, child)
+        if progress is not None:
+            await self.run(parent, lambda ctx: parent.on_fill(ctx, progress, child))
+        await self.run(parent, lambda ctx: parent.on_child(ctx, order, child))
+
+    async def on_timer(self) -> None:
+        now_ms = int(self.engine.clock() * 1000)
+        for parent in self.live():
+            expires_at = parent.request.expires_at
+            if expires_at is not None and now_ms >= expires_at:
+                # The parent's own expiry: the whole order ends, every live
+                # child pulled, whatever its type does on a timer.
+                await self.cancel(parent.id, reason="expired")
+                continue
+            await self.run(parent, lambda ctx, p=parent: p.on_timer(ctx))
+
+    async def on_halt(self, reason: str, *, scope: str = "*") -> int:
+        halted = 0
+        for parent in self.live():
+            if scope != "*" and scope not in parent.venues():
+                continue
+            await self.run(parent, lambda ctx, p=parent: p.on_halt(ctx, reason))
+            halted += 1
+        return halted
+
+    async def cancel(self, parent_id: str, *, reason: str = "cancelled by the caller") -> ManagedOrder:
+        parent = self.parents.get(parent_id)
+        if parent is None:
+            raise KeyError(f"no engine-held order {parent_id!r}")
+        await self.run(parent, lambda ctx: parent.cancel(ctx, reason))
+        return parent
+
+    # -- persistence ----------------------------------------------------------
+
+    async def save(self, parent: ManagedOrder) -> None:
+        for child in parent.children:
+            self.by_child.setdefault(child.order_id, parent.id)
+            self.by_child.setdefault(f"{child.venue}:{child.order_id}", parent.id)
+        await self.engine.journal.save_managed(parent.snapshot())
+        await self.engine.journal.upsert_order(parent.as_order(), event=f"managed.{parent.state}")
+        self.engine._remember(parent.as_order())
+
+    async def restore(self) -> int:
+        """Bring back every parent that was still live, after a restart."""
+        restored = 0
+        for snapshot in await self.engine.journal.managed(states=("waiting", "working", "cancelling")):
+            cls = REGISTRY.get(snapshot.get("kind", ""))
+            if cls is None:
+                log.warning("synpath.engine.orders: no implementation for %s; leaving %s alone",
+                            snapshot.get("kind"), snapshot.get("id"))
+                continue
+            parent = cls.from_snapshot(snapshot)
+            self.remember(parent)
+            restored += 1
+        if restored:
+            await self.engine.bus.publish("managed.restored", {"count": restored})
+        return restored

synpath/engine/orders/oco.py

@@ -0,0 +1,255 @@
+"""One cancels the other, and the bracket built on it.
+
+**OCO** holds two orders where only one should happen: take profit at 0.70
+or stop out at 0.40, buy this market or that one. Each leg is a real order
+in its own right -- a limit at the venue, or another engine-held order like
+a stop -- and the parent's job is to keep them in step.
+
+The linkage is by size, not by existence, because a partial fill is the
+common case on a thin book. When one leg fills two of five contracts, the
+other is replaced at three: leaving it at five would let the pair fill seven.
+When one leg is done, the other is pulled.
+
+**Bracket** is an entry with that pair attached: buy ten at 0.42, and when it
+fills, protect it with a take-profit and a stop-loss sized to what actually
+filled. The protection goes out as the entry fills, contract by contract, so
+a position is never unprotected while the entry works. An entry that is
+cancelled with nothing filled takes the bracket with it.
+
+Both are written to the journal like any other engine-held order, so a
+restart finds the pair and its sizes rather than two loose orders nobody
+links any more.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, Mapping
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType, Side, TimeInForce
+from .base import ZERO, Child, Context, D, ManagedOrder
+from .manager import register
+
+VENUE_TYPES = (OrderType.LIMIT, OrderType.MARKET)
+
+
+def leg_request(spec: Mapping[str, Any], *, parent: ManagedOrder, amount: Decimal | None = None) -> OrderRequest:
+    """One leg's request, inheriting what the parent already knows."""
+    body: dict[str, Any] = {
+        "market_id": spec.get("market_id", parent.market_id),
+        "side": spec.get("side", parent.side.value),
+        "amount": str(amount if amount is not None else D(spec.get("amount"), parent.amount)),
+        "type": spec.get("type", "limit"),
+        "account": parent.account.model_dump(mode="json"),
+        "book": parent.request.book,
+        "trader": parent.request.trader,
+        "tags": {**parent.request.tags, "parent": parent.id},
+    }
+    for key in ("price", "stop_price", "time_in_force", "expires_at", "post_only", "reduce_only", "params"):
+        if spec.get(key) is not None:
+            body[key] = spec[key]
+    if "reduce_only" not in body and parent.request.reduce_only:
+        body["reduce_only"] = True
+    return OrderRequest.model_validate(body)
+
+
+class _Linked(ManagedOrder):
+    """Shared machinery for parents whose legs must be resized together."""
+
+    async def place_leg(self, ctx: Context, spec: Mapping[str, Any], amount: Decimal, tag: str) -> Child:
+        request = leg_request(spec, parent=self, amount=amount)
+        order = await ctx.submit_child(request)
+        child = self.track(order, amount, D(request.price))
+        self.leg_of[child.order_id] = tag
+        self.spec_of[tag] = dict(spec)
+        await ctx.publish("managed.leg", {"leg": tag, "order_id": order.id, "amount": str(amount),
+                                          "type": str(spec.get("type", "limit"))})
+        return child
+
+    async def resize_leg(self, ctx: Context, tag: str, amount: Decimal) -> None:
+        """Cancel and re-place a leg at a new size; below one contract, pull it."""
+        for child in list(self.live_children):
+            if self.leg_of.get(child.order_id) != tag:
+                continue
+            await ctx.cancel_child(child.order_id)
+            child.status = "canceled"
+        if amount <= 0:
+            return
+        spec = self.spec_of.get(tag)
+        if spec:
+            await self.place_leg(ctx, spec, amount, tag)
+
+    def leg_children(self, tag: str) -> list[Child]:
+        return [c for c in self.children if self.leg_of.get(c.order_id) == tag]
+
+    def extra(self) -> dict[str, Any]:
+        return {"leg_of": dict(self.leg_of), "spec_of": {k: dict(v) for k, v in self.spec_of.items()}}
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        self.leg_of = dict(extra.get("leg_of") or {})
+        self.spec_of = {k: dict(v) for k, v in (extra.get("spec_of") or {}).items()}
+
+
+@register
+class OCO(_Linked):
+    """`params`: `legs`, a list of two order specifications."""
+
+    kind = "oco"
+    order_type = OrderType.OCO
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.leg_of: dict[str, str] = {}
+        self.spec_of: dict[str, dict[str, Any]] = {}
+        legs = self.params.get("legs") or []
+        if len(legs) != 2:
+            raise ValueError("an OCO needs params legs: exactly two order specifications")
+        self.legs = [dict(leg) for leg in legs]
+
+    def markets(self) -> list[str]:
+        return list({self.market_id, *(str(leg.get("market_id") or self.market_id) for leg in self.legs)})
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        for index, spec in enumerate(self.legs):
+            await self.place_leg(ctx, spec, self.remaining, f"leg{index}")
+        await ctx.save()
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        tag = self.leg_of.get(child.order_id, "")
+        other = "leg1" if tag == "leg0" else "leg0"
+        if self.remaining <= 0:
+            await self.cancel_other(ctx, other, "the other leg filled")
+            await self.finish(ctx, "done", "filled")
+            return
+        # Partly filled: the other leg must not be able to fill the same size.
+        await self.resize_leg(ctx, other, self.remaining)
+        await ctx.save()
+
+    async def cancel_other(self, ctx: Context, tag: str, reason: str) -> None:
+        for child in self.leg_children(tag):
+            if child.live:
+                await ctx.cancel_child(child.order_id)
+                child.status = "canceled"
+        await ctx.publish("managed.leg_canceled", {"leg": tag, "reason": reason})
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if not order.is_terminal or self.state != "working":
+            return
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+            return
+        if not self.live_children:
+            await self.finish(ctx, "canceled", f"both legs ended with {self.remaining} unfilled")
+
+    def extra(self) -> dict[str, Any]:
+        return super().extra() | {"legs": self.legs}
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        super().load_extra(extra)
+        self.legs = [dict(leg) for leg in extra.get("legs") or self.params.get("legs") or []]
+
+
+@register
+class Bracket(_Linked):
+    """`params`: `entry` (optional), `take_profit`, `stop_loss`.
+
+    Without an entry the protection is placed at once, for a position that
+    already exists.
+    """
+
+    kind = "bracket"
+    order_type = OrderType.BRACKET
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.leg_of: dict[str, str] = {}
+        self.spec_of: dict[str, dict[str, Any]] = {}
+        self.entry = dict(self.params["entry"]) if self.params.get("entry") else None
+        self.take_profit = dict(self.params.get("take_profit") or {})
+        self.stop_loss = dict(self.params.get("stop_loss") or {})
+        if not self.take_profit and not self.stop_loss:
+            raise ValueError("a bracket needs params take_profit, stop_loss, or both")
+        self.entered: Decimal = ZERO
+        """Contracts the entry has filled, which is what the protection covers."""
+        self.protected: Decimal = ZERO
+
+    def markets(self) -> list[str]:
+        return [self.market_id]
+
+    def exit_side(self) -> str:
+        """Protection closes the position the entry opens."""
+        return (Side.SELL if self.side == Side.BUY else Side.BUY).value
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        if self.entry is not None:
+            await self.place_leg(ctx, {**self.entry, "side": self.side.value}, self.amount, "entry")
+        else:
+            self.entered = self.amount
+            await self.protect(ctx, self.amount)
+        await ctx.save()
+
+    async def protect(self, ctx: Context, amount: Decimal) -> None:
+        """Put the take-profit and the stop-loss out for `amount` contracts."""
+        if amount <= 0:
+            return
+        side = self.exit_side()
+        if self.take_profit:
+            await self.place_leg(ctx, {**self.take_profit, "side": side}, amount, "take_profit")
+        if self.stop_loss:
+            spec = {"type": "stop_market", **self.stop_loss, "side": side}
+            await self.place_leg(ctx, spec, amount, "stop_loss")
+        self.protected += amount
+        await ctx.publish("managed.protected", {"amount": str(amount), "protected": str(self.protected)})
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        tag = self.leg_of.get(child.order_id, "")
+        if tag == "entry":
+            self.entered += fill.amount
+            # Protect what has actually been bought, as it is bought.
+            await self.protect(ctx, fill.amount)
+            await ctx.save()
+            return
+        # An exit filled: the other side of the protection must shrink.
+        other = "stop_loss" if tag == "take_profit" else "take_profit"
+        remaining = max(ZERO, self.protected - self.exit_filled())
+        await self.resize_leg(ctx, other, remaining)
+        if remaining <= 0 and self.entry_done():
+            await self.finish(ctx, "done", "the position was closed")
+        await ctx.save()
+
+    def exit_filled(self) -> Decimal:
+        return sum((c.filled for c in self.children if self.leg_of.get(c.order_id) in ("take_profit", "stop_loss")), ZERO)
+
+    def entry_done(self) -> bool:
+        if self.entry is None:
+            return True
+        entry_children = self.leg_children("entry")
+        return bool(entry_children) and not any(c.live for c in entry_children)
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        tag = self.leg_of.get(child.order_id, "")
+        if self.state != "working" or not order.is_terminal:
+            return
+        if tag == "entry" and self.entered <= 0:
+            await self.finish(ctx, "canceled", "the entry ended without filling")
+            return
+        if tag in ("take_profit", "stop_loss") and self.exit_filled() >= self.protected > 0:
+            await self.finish(ctx, "done", "the position was closed")
+
+    async def cancel(self, ctx: Context, reason: str = "cancelled") -> None:
+        await super().cancel(ctx, reason)
+
+    def extra(self) -> dict[str, Any]:
+        return super().extra() | {
+            "entry": self.entry, "take_profit": self.take_profit, "stop_loss": self.stop_loss,
+            "entered": str(self.entered), "protected": str(self.protected),
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        super().load_extra(extra)
+        self.entry = dict(extra["entry"]) if extra.get("entry") else None
+        self.take_profit = dict(extra.get("take_profit") or {})
+        self.stop_loss = dict(extra.get("stop_loss") or {})
+        self.entered = D(extra.get("entered"), ZERO)
+        self.protected = D(extra.get("protected"), ZERO)

synpath/engine/orders/peg.py

@@ -0,0 +1,168 @@
+"""Peg: stay at the touch without chasing it.
+
+A pegged order follows a reference price -- the near touch, the far touch or
+the mid -- and re-prices when the reference moves. On a thin prediction
+market that is how a maker stays at the front of the queue without watching
+a screen, and also how a naive implementation burns its rate limit and its
+queue position in a minute.
+
+Three restraints, all of them the point:
+
+**A minimum stay.** `min_stay_s` is how long an order must sit before it may
+be moved at all. Without it, a flickering touch re-prices the order every few
+hundred milliseconds, and each move goes to the back of the queue.
+
+**A level cap.** `level_cap` counts how many times the order may be moved
+before the peg gives up and stays where it is. A market that runs away from
+you is not one to follow to the end of the book.
+
+**Bounds.** `min_price` and `max_price` are the range within which the peg
+may operate. Outside them it waits rather than trades, because a peg with no
+bound is an instruction to pay anything.
+
+`offset` sits the order behind the reference: a buy peg with offset 0.01 at a
+0.41 bid rests at 0.40. Re-pricing is cancel and replace, which loses queue
+priority on every venue here, so the parent counts the moves and reports
+them.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType, Side, TimeInForce
+from .base import ZERO, Child, Context, D, ManagedOrder
+from .manager import register
+
+REFERENCES = ("near", "far", "mid")
+
+
+@register
+class Peg(ManagedOrder):
+    """`params`: `reference`, `offset`, `min_stay_s`, `level_cap`, `min_price`, `max_price`."""
+
+    kind = "peg"
+    order_type = OrderType.PEG
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.reference = str(self.params.get("reference") or "near")
+        if self.reference not in REFERENCES:
+            raise ValueError(f"a peg's reference is one of {REFERENCES}")
+        self.offset = D(self.params.get("offset"), ZERO)
+        self.min_stay_s = float(self.params.get("min_stay_s") or 0)
+        self.level_cap = int(self.params.get("level_cap") or 0)
+        self.min_price = D(self.params.get("min_price"))
+        self.max_price = D(self.params.get("max_price"))
+        self.moves = 0
+        self.placed_at: float = 0.0
+        self.resting_price: Decimal | None = None
+
+    # -- where the peg wants to be -------------------------------------------
+
+    def target(self, ctx: Context) -> Decimal | None:
+        book = ctx.book()
+        if book is None:
+            return None
+        if self.reference == "mid":
+            reference = ctx.mid()
+        elif self.reference == "near":
+            reference = book.best_bid if self.side == Side.BUY else book.best_ask
+        else:
+            reference = book.best_ask if self.side == Side.BUY else book.best_bid
+        if reference is None:
+            return None
+        price = reference - self.offset if self.side == Side.BUY else reference + self.offset
+        # The bounds cap the chase rather than stopping it: a buy peg whose
+        # reference runs past its maximum rests at the maximum, where it may
+        # still be hit, instead of leaving the market entirely.
+        if self.min_price is not None:
+            price = max(price, self.min_price)
+        if self.max_price is not None:
+            price = min(price, self.max_price)
+        return price
+
+    def may_move(self, ctx: Context) -> bool:
+        if self.level_cap and self.moves >= self.level_cap:
+            return False
+        return ctx.now - self.placed_at >= self.min_stay_s
+
+    # -- running --------------------------------------------------------------
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        await self.reprice(ctx, first=True)
+
+    async def on_book(self, ctx: Context, market_id: str) -> None:
+        if self.state != "working":
+            return
+        target = self.target(ctx)
+        if target is None or target == self.resting_price:
+            return
+        if not self.live_children:
+            await self.reprice(ctx)
+            return
+        if self.may_move(ctx):
+            await self.reprice(ctx)
+
+    async def on_timer(self, ctx: Context) -> None:
+        if self.state == "working" and not self.live_children and self.remaining > 0:
+            await self.reprice(ctx)
+
+    async def reprice(self, ctx: Context, *, first: bool = False) -> None:
+        target = self.target(ctx)
+        if target is None:
+            if self.live_children:
+                for child in self.live_children:
+                    await ctx.cancel_child(child.order_id)
+                    child.status = "canceled"
+                await ctx.publish("managed.peg_paused", {"reason": "the reference is outside the bounds"})
+                await ctx.save()
+            return
+        for child in self.live_children:
+            await ctx.cancel_child(child.order_id)
+            child.status = "canceled"
+        size = self.remaining
+        if size <= 0:
+            await self.complete_if_done(ctx)
+            return
+        request = self.child_request(amount=size, price=target, type=OrderType.LIMIT,
+                                     time_in_force=TimeInForce.GTC, post_only=self.request.post_only)
+        order = await ctx.submit_child(request)
+        self.track(order, size, target)
+        self.resting_price = target
+        self.placed_at = ctx.now
+        if not first:
+            self.moves += 1
+        await ctx.publish("managed.pegged", {"price": str(target), "moves": self.moves,
+                                             "capped": bool(self.level_cap and self.moves >= self.level_cap)})
+        await ctx.save()
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        await self.complete_if_done(ctx)
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if self.state != "working" or not order.is_terminal:
+            return
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+
+    def extra(self) -> dict[str, Any]:
+        return {
+            "reference": self.reference, "offset": str(self.offset), "min_stay_s": self.min_stay_s,
+            "level_cap": self.level_cap, "moves": self.moves, "placed_at": self.placed_at,
+            "min_price": str(self.min_price) if self.min_price is not None else None,
+            "max_price": str(self.max_price) if self.max_price is not None else None,
+            "resting_price": str(self.resting_price) if self.resting_price is not None else None,
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        self.reference = extra.get("reference", self.reference)
+        self.offset = D(extra.get("offset"), ZERO)
+        self.min_stay_s = float(extra.get("min_stay_s") or 0)
+        self.level_cap = int(extra.get("level_cap") or 0)
+        self.moves = int(extra.get("moves") or 0)
+        self.placed_at = float(extra.get("placed_at") or 0)
+        self.min_price = D(extra.get("min_price"))
+        self.max_price = D(extra.get("max_price"))
+        self.resting_price = D(extra.get("resting_price"))