@blockrun/franklin 3.7.10 → 3.8.0

package/dist/tools/trading-execute.js

@@ -0,0 +1,297 @@
+/**
+ * Trading execution capabilities. Exposes Franklin's Portfolio + RiskEngine
+ * + Exchange stack to the agent as three tools: TradingPortfolio (read),
+ * TradingOpenPosition (buy side), TradingClosePosition (sell side).
+ *
+ * This is the surface that differentiates Franklin from generic coding
+ * agents — Claude Code and Cursor cannot hold a wallet, track positions
+ * across sessions, or reason about P&L. Every output here is deliberately
+ * information-rich so the agent has the numbers it needs to make the next
+ * economic decision (cash left, risk utilization, unrealized vs realized
+ * P&L, fill detail) without a follow-up tool call.
+ *
+ * Factory-style construction (createTradingCapabilities) keeps testing
+ * clean: production code calls it with a default disk-backed engine;
+ * tests inject a MockExchange-backed engine and assert behavior without
+ * touching disk.
+ */
+function formatUsd(n) {
+    const sign = n < 0 ? '-' : '';
+    const abs = Math.abs(n);
+    return `${sign}$${abs.toFixed(2)}`;
+}
+function formatPct(n) {
+    return `${(n * 100).toFixed(1)}%`;
+}
+function formatPositionLine(p) {
+    const pctReturn = (p.markUsd - p.avgPriceUsd) / p.avgPriceUsd;
+    const arrow = p.unrealizedPnlUsd >= 0 ? '↑' : '↓';
+    return (`- **${p.symbol}** qty=${p.qty} @ avg ${formatUsd(p.avgPriceUsd)} ` +
+        `| mark ${formatUsd(p.markUsd)} ${arrow} ` +
+        `| unrealized ${formatUsd(p.unrealizedPnlUsd)} (${formatPct(pctReturn)})`);
+}
+/** Parse a window string (e.g. "24h", "7d", "all") into a lower-bound timestamp. */
+function windowToSince(window, now) {
+    const m = /^(\d+)\s*([hdwm])$/i.exec(window.trim());
+    if (!m)
+        return 0; // "all" or anything unparseable → since epoch
+    const n = parseInt(m[1], 10);
+    switch (m[2].toLowerCase()) {
+        case 'h': return now - n * 3_600_000;
+        case 'd': return now - n * 86_400_000;
+        case 'w': return now - n * 7 * 86_400_000;
+        case 'm': return now - n * 30 * 86_400_000;
+        default: return 0;
+    }
+}
+function formatTradeLine(entry) {
+    const when = new Date(entry.timestamp).toISOString().replace('T', ' ').slice(0, 16);
+    const side = entry.side.toUpperCase();
+    const pnl = entry.realizedPnlUsd === 0 ? '' : ` → realized ${formatUsd(entry.realizedPnlUsd)}`;
+    return `- ${when}  ${side} ${entry.qty} ${entry.symbol} @ ${formatUsd(entry.priceUsd)}${pnl}`;
+}
+export function createTradingCapabilities(deps) {
+    const { engine, riskConfig, onStateChange, tradeLog } = deps;
+    const tradingPortfolio = {
+        spec: {
+            name: 'TradingPortfolio',
+            description: 'Report current paper-trading portfolio: cash, open positions with unrealized P&L, ' +
+                'and realized P&L across the session. No inputs. Use this before deciding whether ' +
+                'to open, close, or hold a position.',
+            input_schema: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false,
+            },
+        },
+        concurrent: true,
+        async execute(_input, _ctx) {
+            // markToMarket against current exchange prices; fall back to avg price
+            // (flat unrealized) when the exchange doesn't know the symbol.
+            const priceTable = {};
+            for (const p of engine.deps.portfolio.listPositions()) {
+                const quote = await engine.deps.exchange.getPrice(p.symbol);
+                if (quote != null)
+                    priceTable[p.symbol] = quote;
+            }
+            const portfolio = engine.deps.portfolio;
+            const snap = portfolio.markToMarket(priceTable);
+            const lines = [];
+            lines.push('## Portfolio');
+            lines.push(`- Cash: ${formatUsd(snap.cashUsd)}`);
+            lines.push(`- Equity (cash + positions marked-to-market): ${formatUsd(snap.equityUsd)}`);
+            lines.push(`- Unrealized P&L: ${formatUsd(snap.unrealizedPnlUsd)}`);
+            lines.push(`- Realized P&L (this session): ${formatUsd(snap.realizedPnlUsd)}`);
+            lines.push('');
+            if (snap.positions.length === 0) {
+                lines.push('_No open positions._');
+            }
+            else {
+                lines.push('### Open positions');
+                for (const p of snap.positions)
+                    lines.push(formatPositionLine(p));
+            }
+            if (riskConfig) {
+                const totalExposure = snap.positions.reduce((a, p) => a + p.qty * p.markUsd, 0);
+                lines.push('');
+                lines.push('### Risk utilization');
+                lines.push(`- Total exposure: ${formatUsd(totalExposure)} / cap ${formatUsd(riskConfig.maxTotalExposureUsd)} ` +
+                    `(${formatPct(totalExposure / riskConfig.maxTotalExposureUsd)})`);
+            }
+            return { output: lines.join('\n') };
+        },
+    };
+    const tradingOpenPosition = {
+        spec: {
+            name: 'TradingOpenPosition',
+            description: 'Open (buy into) a position. Pre-trade risk checks enforce per-position and total ' +
+                'exposure caps; a blocked order returns a normal text result with the reason — the ' +
+                'agent should read it and try again with a smaller qty if appropriate. This is paper ' +
+                'trading: fills are simulated against the provided price.',
+            input_schema: {
+                type: 'object',
+                required: ['symbol', 'qty', 'priceUsd'],
+                properties: {
+                    symbol: { type: 'string', description: 'Ticker (e.g., "BTC", "ETH")' },
+                    qty: { type: 'number', description: 'Quantity in base units (e.g., 0.01 for 0.01 BTC)' },
+                    priceUsd: { type: 'number', description: 'Price at which to execute, in USD' },
+                },
+                additionalProperties: false,
+            },
+        },
+        concurrent: false,
+        async execute(input, _ctx) {
+            const symbol = String(input.symbol ?? '').toUpperCase();
+            const qty = Number(input.qty);
+            const priceUsd = Number(input.priceUsd);
+            if (!symbol || !Number.isFinite(qty) || qty <= 0 || !Number.isFinite(priceUsd) || priceUsd <= 0) {
+                return {
+                    output: 'Error: TradingOpenPosition requires symbol (string), qty (>0), priceUsd (>0).',
+                    isError: true,
+                };
+            }
+            const outcome = await engine.openPosition({ symbol, qty, priceUsd });
+            if (outcome.status === 'blocked') {
+                // Not an agent error — a legitimate risk decision the agent must read.
+                return {
+                    output: `## Order blocked\n` +
+                        `- Symbol: ${symbol}\n` +
+                        `- Attempted: buy ${qty} @ ${formatUsd(priceUsd)}\n` +
+                        `- Reason: ${outcome.reason}\n\n` +
+                        `Try a smaller qty, or close other positions first to free up exposure headroom.`,
+                };
+            }
+            if (outcome.status === 'noop') {
+                return { output: `No-op: ${outcome.reason}` };
+            }
+            if (tradeLog) {
+                tradeLog.append({
+                    timestamp: Date.now(),
+                    symbol,
+                    side: 'buy',
+                    qty: outcome.fill.qty,
+                    priceUsd: outcome.fill.priceUsd,
+                    feeUsd: outcome.fill.feeUsd,
+                    realizedPnlUsd: 0,
+                });
+            }
+            if (onStateChange)
+                await onStateChange();
+            const portfolio = engine.deps.portfolio;
+            const pos = portfolio.getPosition(symbol);
+            return {
+                output: `## Order filled\n` +
+                    `- Bought ${outcome.fill.qty} ${symbol} @ ${formatUsd(outcome.fill.priceUsd)} ` +
+                    `(fee ${formatUsd(outcome.fill.feeUsd)})\n` +
+                    `- Position now: ${pos ? `${pos.qty} ${symbol} @ avg ${formatUsd(pos.avgPriceUsd)}` : '(none)'}\n` +
+                    `- Cash remaining: ${formatUsd(portfolio.cashUsd)}`,
+            };
+        },
+    };
+    const tradingClosePosition = {
+        spec: {
+            name: 'TradingClosePosition',
+            description: 'Close (sell) an open position, realizing P&L against the average entry price. ' +
+                'Omit qty to flatten the position entirely; pass qty to partially reduce. Uses the ' +
+                'exchange\'s current mark — no manual price required.',
+            input_schema: {
+                type: 'object',
+                required: ['symbol'],
+                properties: {
+                    symbol: { type: 'string', description: 'Ticker of the position to close' },
+                    qty: {
+                        type: 'number',
+                        description: 'Optional — partial size. Omit to close the full position.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        concurrent: false,
+        async execute(input, _ctx) {
+            const symbol = String(input.symbol ?? '').toUpperCase();
+            const qty = input.qty != null ? Number(input.qty) : undefined;
+            if (!symbol) {
+                return {
+                    output: 'Error: TradingClosePosition requires symbol.',
+                    isError: true,
+                };
+            }
+            if (qty != null && (!Number.isFinite(qty) || qty <= 0)) {
+                return {
+                    output: 'Error: if qty is provided, it must be > 0.',
+                    isError: true,
+                };
+            }
+            const portfolio = engine.deps.portfolio;
+            const priorRealized = portfolio.realizedPnlUsd;
+            const outcome = await engine.closePosition({ symbol, qty });
+            if (outcome.status === 'noop') {
+                return { output: `No open ${symbol} position to close.` };
+            }
+            if (outcome.status === 'blocked') {
+                return {
+                    output: `## Close blocked\n- Symbol: ${symbol}\n- Reason: ${outcome.reason}`,
+                };
+            }
+            const tradeRealized = portfolio.realizedPnlUsd - priorRealized;
+            if (tradeLog) {
+                tradeLog.append({
+                    timestamp: Date.now(),
+                    symbol,
+                    side: 'sell',
+                    qty: outcome.fill.qty,
+                    priceUsd: outcome.fill.priceUsd,
+                    feeUsd: outcome.fill.feeUsd,
+                    realizedPnlUsd: tradeRealized,
+                });
+            }
+            if (onStateChange)
+                await onStateChange();
+            const remaining = portfolio.getPosition(symbol);
+            return {
+                output: `## Position closed\n` +
+                    `- Sold ${outcome.fill.qty} ${symbol} @ ${formatUsd(outcome.fill.priceUsd)} ` +
+                    `(fee ${formatUsd(outcome.fill.feeUsd)})\n` +
+                    `- Realized on this trade: ${formatUsd(tradeRealized)}\n` +
+                    `- Remaining ${symbol}: ${remaining ? `${remaining.qty} @ avg ${formatUsd(remaining.avgPriceUsd)}` : '(flat)'}\n` +
+                    `- Cash: ${formatUsd(portfolio.cashUsd)} · ` +
+                    `Session realized P&L: ${formatUsd(portfolio.realizedPnlUsd)}`,
+            };
+        },
+    };
+    const caps = [tradingPortfolio, tradingOpenPosition, tradingClosePosition];
+    if (tradeLog) {
+        const tradingHistory = {
+            spec: {
+                name: 'TradingHistory',
+                description: 'Show recent trades and realized P&L within a time window. Unlike ephemeral ' +
+                    'session state, this reads the persistent trade log so it spans every prior ' +
+                    'session on this machine. Use to answer "am I up this week?", "what was my ' +
+                    'worst trade?", "how often am I flipping BTC?".',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        window: {
+                            type: 'string',
+                            description: 'Time window: "24h", "7d", "30d", "all". Default "7d".',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Max number of trade rows to list. Default 20.',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            concurrent: true,
+            async execute(input, _ctx) {
+                const windowRaw = String(input.window ?? '7d').trim();
+                const limit = Number.isFinite(Number(input.limit))
+                    ? Math.max(1, Math.min(200, Number(input.limit)))
+                    : 20;
+                const now = Date.now();
+                const since = windowRaw.toLowerCase() === 'all' ? 0 : windowToSince(windowRaw, now);
+                const entries = tradeLog.recent(limit).filter((e) => e.timestamp >= since);
+                const realized = tradeLog.realizedSince(since);
+                const opens = entries.filter((e) => e.side === 'buy').length;
+                const closes = entries.filter((e) => e.side === 'sell').length;
+                const lines = [];
+                lines.push(`## Trade history (${windowRaw})`);
+                lines.push(`- ${windowRaw} P&L (realized): ${formatUsd(realized)}`);
+                lines.push(`- Trades: ${entries.length} (${opens} opens, ${closes} closes)`);
+                lines.push('');
+                if (entries.length === 0) {
+                    lines.push('_No trades in this window._');
+                }
+                else {
+                    for (const e of entries)
+                        lines.push(formatTradeLine(e));
+                }
+                return { output: lines.join('\n') };
+            },
+        };
+        caps.push(tradingHistory);
+    }
+    return caps;
+}

package/dist/tools/webfetch.d.ts

@@ -2,4 +2,10 @@
  * WebFetch capability — fetch web page content.
  */
 import type { CapabilityHandler } from '../agent/types.js';
+/**
+ * Drop every cached fetch so a fresh session doesn't serve stale content
+ * that was fetched under the previous session's intent. The 15-minute TTL
+ * would eventually catch this, but we'd rather start clean.
+ */
+export declare function clearSessionState(): void;
 export declare const webFetchCapability: CapabilityHandler;

package/dist/tools/webfetch.js

@@ -33,6 +33,14 @@ function setCached(key, output) {
     }
     fetchCache.set(key, { output, expiresAt: Date.now() + CACHE_TTL_MS });
 }
+/**
+ * Drop every cached fetch so a fresh session doesn't serve stale content
+ * that was fetched under the previous session's intent. The 15-minute TTL
+ * would eventually catch this, but we'd rather start clean.
+ */
+export function clearSessionState() {
+    fetchCache.clear();
+}
 // ─── Execute ────────────────────────────────────────────────────────────────
 async function execute(input, ctx) {
     const { url, max_length } = input;

package/dist/trading/engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TradingEngine — composes Portfolio + RiskEngine + ExchangeClient into the
+ * single surface the Franklin capabilities call into.
+ *
+ * Responsibilities:
+ *  - Pre-trade risk check (refuse the order if it would breach caps).
+ *  - Route the order to the Exchange (mock or real adapter).
+ *  - Apply the resulting Fill to the Portfolio.
+ *
+ * The engine holds no state itself beyond the injected dependencies; that
+ * keeps the class easy to unit-test and lets us swap the ExchangeClient for
+ * a real adapter without touching capability plumbing.
+ */
+import type { ExchangeClient } from './mock-exchange.js';
+import type { Portfolio } from './portfolio.js';
+import type { RiskEngine } from './risk.js';
+export interface OpenPositionRequest {
+    symbol: string;
+    qty: number;
+    priceUsd: number;
+}
+export interface CloseRequest {
+    symbol: string;
+    qty?: number;
+}
+export type Outcome = {
+    status: 'filled';
+    fill: {
+        symbol: string;
+        qty: number;
+        priceUsd: number;
+        feeUsd: number;
+    };
+} | {
+    status: 'blocked';
+    reason: string;
+} | {
+    status: 'noop';
+    reason: string;
+};
+export interface TradingEngineDeps {
+    portfolio: Portfolio;
+    risk: RiskEngine;
+    exchange: ExchangeClient;
+}
+export declare class TradingEngine {
+    private deps;
+    constructor(deps: TradingEngineDeps);
+    openPosition(req: OpenPositionRequest): Promise<Outcome>;
+    closePosition(req: CloseRequest): Promise<Outcome>;
+}

package/dist/trading/engine.js

@@ -0,0 +1,75 @@
+/**
+ * TradingEngine — composes Portfolio + RiskEngine + ExchangeClient into the
+ * single surface the Franklin capabilities call into.
+ *
+ * Responsibilities:
+ *  - Pre-trade risk check (refuse the order if it would breach caps).
+ *  - Route the order to the Exchange (mock or real adapter).
+ *  - Apply the resulting Fill to the Portfolio.
+ *
+ * The engine holds no state itself beyond the injected dependencies; that
+ * keeps the class easy to unit-test and lets us swap the ExchangeClient for
+ * a real adapter without touching capability plumbing.
+ */
+export class TradingEngine {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async openPosition(req) {
+        const { portfolio, risk, exchange } = this.deps;
+        const decision = risk.check(portfolio, {
+            symbol: req.symbol,
+            side: 'buy',
+            qty: req.qty,
+            priceUsd: req.priceUsd,
+        });
+        if (!decision.allowed) {
+            return { status: 'blocked', reason: decision.reason ?? 'blocked by risk engine' };
+        }
+        const fill = await exchange.placeOrder({
+            symbol: req.symbol,
+            side: 'buy',
+            qty: req.qty,
+            priceUsd: req.priceUsd,
+        });
+        portfolio.applyFill(fill);
+        return {
+            status: 'filled',
+            fill: {
+                symbol: fill.symbol,
+                qty: fill.qty,
+                priceUsd: fill.priceUsd,
+                feeUsd: fill.feeUsd ?? 0,
+            },
+        };
+    }
+    async closePosition(req) {
+        const { portfolio, exchange } = this.deps;
+        const existing = portfolio.getPosition(req.symbol);
+        if (!existing) {
+            return { status: 'noop', reason: `No open ${req.symbol} position` };
+        }
+        const qty = req.qty ?? existing.qty;
+        const price = (await exchange.getPrice(req.symbol));
+        if (price == null) {
+            return { status: 'blocked', reason: `Exchange returned no price for ${req.symbol}` };
+        }
+        const fill = await exchange.placeOrder({
+            symbol: req.symbol,
+            side: 'sell',
+            qty,
+            priceUsd: price,
+        });
+        portfolio.applyFill(fill);
+        return {
+            status: 'filled',
+            fill: {
+                symbol: fill.symbol,
+                qty: fill.qty,
+                priceUsd: fill.priceUsd,
+                feeUsd: fill.feeUsd ?? 0,
+            },
+        };
+    }
+}

package/dist/trading/live-exchange.d.ts

@@ -0,0 +1,43 @@
+/**
+ * LiveExchange — ExchangeClient backed by a real pricing source (CoinGecko
+ * by default) but with *simulated* fills. This is the default adapter the
+ * agent uses out of the box: it sees real market prices when valuing
+ * positions (so P&L tracks reality) but trades are paper — no real assets
+ * are moved, no real USDC is spent on exchange fees.
+ *
+ * A future commit will add a `RealExchange` that actually routes orders
+ * through Coinbase/Kraken; it plugs into the same ExchangeClient contract
+ * here. Keep this seam clean: the agent loop, risk engine, and portfolio
+ * math never need to know whether they're in paper or live mode.
+ *
+ * Pricing is injected (not imported directly from `./data.js`) so tests
+ * can validate behavior without hitting CoinGecko.
+ */
+import type { ExchangeClient } from './mock-exchange.js';
+import type { Fill, Side } from './portfolio.js';
+/** Subset of src/trading/data.ts's PriceData that we actually consume. */
+export interface PricingClientResponse {
+    price: number;
+    change24h: number;
+    volume24h: number;
+    marketCap: number;
+}
+export interface PricingClient {
+    /** Returns live price data on success, a string error on failure — matches data.ts. */
+    getPrice(ticker: string): Promise<PricingClientResponse | string>;
+}
+export interface LiveExchangeOptions {
+    pricing: PricingClient;
+    feeBps: number;
+}
+export declare class LiveExchange implements ExchangeClient {
+    private opts;
+    constructor(opts: LiveExchangeOptions);
+    getPrice(symbol: string): Promise<number | null>;
+    placeOrder(order: {
+        symbol: string;
+        side: Side;
+        qty: number;
+        priceUsd: number;
+    }): Promise<Fill>;
+}

package/dist/trading/live-exchange.js

@@ -0,0 +1,48 @@
+/**
+ * LiveExchange — ExchangeClient backed by a real pricing source (CoinGecko
+ * by default) but with *simulated* fills. This is the default adapter the
+ * agent uses out of the box: it sees real market prices when valuing
+ * positions (so P&L tracks reality) but trades are paper — no real assets
+ * are moved, no real USDC is spent on exchange fees.
+ *
+ * A future commit will add a `RealExchange` that actually routes orders
+ * through Coinbase/Kraken; it plugs into the same ExchangeClient contract
+ * here. Keep this seam clean: the agent loop, risk engine, and portfolio
+ * math never need to know whether they're in paper or live mode.
+ *
+ * Pricing is injected (not imported directly from `./data.js`) so tests
+ * can validate behavior without hitting CoinGecko.
+ */
+export class LiveExchange {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async getPrice(symbol) {
+        try {
+            const resp = await this.opts.pricing.getPrice(symbol.toUpperCase());
+            if (typeof resp === 'string')
+                return null;
+            if (typeof resp.price !== 'number' || !Number.isFinite(resp.price))
+                return null;
+            return resp.price;
+        }
+        catch {
+            // Network errors, DNS failures, etc — treat as "price unknown" rather
+            // than throwing, so the agent gets a clean "can't close, no price"
+            // signal from TradingClosePosition instead of an uncaught exception.
+            return null;
+        }
+    }
+    async placeOrder(order) {
+        const notional = order.qty * order.priceUsd;
+        const feeUsd = (notional * this.opts.feeBps) / 10_000;
+        return {
+            symbol: order.symbol,
+            side: order.side,
+            qty: order.qty,
+            priceUsd: order.priceUsd,
+            feeUsd,
+        };
+    }
+}

package/dist/trading/mock-exchange.d.ts

@@ -0,0 +1,40 @@
+/**
+ * MockExchange — deterministic in-memory exchange used by tests and dev mode.
+ *
+ * Implements the same `ExchangeClient` contract a real adapter would, so the
+ * agent flow can be verified end-to-end without hitting a network or placing
+ * real orders. Fills land at the requested price (no slippage) with a
+ * configured taker fee in basis points; no latency is simulated.
+ *
+ * When a real Coinbase/Kraken adapter lands (follow-up PR), it replaces
+ * MockExchange at the ExchangeClient seam — no Portfolio or RiskEngine
+ * changes required.
+ */
+import type { Fill, Side } from './portfolio.js';
+export interface ExchangeClient {
+    placeOrder(order: {
+        symbol: string;
+        side: Side;
+        qty: number;
+        priceUsd: number;
+    }): Promise<Fill>;
+    getPrice(symbol: string): Promise<number | null>;
+}
+export interface MockExchangeOptions {
+    prices: Record<string, number>;
+    feeBps: number;
+}
+export declare class MockExchange implements ExchangeClient {
+    private prices;
+    private feeBps;
+    constructor(opts: MockExchangeOptions);
+    /** Update the synthetic price book (e.g. to simulate a move in tests). */
+    setPrice(symbol: string, priceUsd: number): void;
+    placeOrder(order: {
+        symbol: string;
+        side: Side;
+        qty: number;
+        priceUsd: number;
+    }): Promise<Fill>;
+    getPrice(symbol: string): Promise<number | null>;
+}

package/dist/trading/mock-exchange.js

@@ -0,0 +1,41 @@
+/**
+ * MockExchange — deterministic in-memory exchange used by tests and dev mode.
+ *
+ * Implements the same `ExchangeClient` contract a real adapter would, so the
+ * agent flow can be verified end-to-end without hitting a network or placing
+ * real orders. Fills land at the requested price (no slippage) with a
+ * configured taker fee in basis points; no latency is simulated.
+ *
+ * When a real Coinbase/Kraken adapter lands (follow-up PR), it replaces
+ * MockExchange at the ExchangeClient seam — no Portfolio or RiskEngine
+ * changes required.
+ */
+export class MockExchange {
+    prices;
+    feeBps;
+    constructor(opts) {
+        this.prices = { ...opts.prices };
+        this.feeBps = opts.feeBps;
+    }
+    /** Update the synthetic price book (e.g. to simulate a move in tests). */
+    setPrice(symbol, priceUsd) {
+        this.prices[symbol] = priceUsd;
+    }
+    async placeOrder(order) {
+        if (!(order.symbol in this.prices)) {
+            throw new Error(`MockExchange has no quote for ${order.symbol}`);
+        }
+        const notional = order.qty * order.priceUsd;
+        const feeUsd = (notional * this.feeBps) / 10_000;
+        return {
+            symbol: order.symbol,
+            side: order.side,
+            qty: order.qty,
+            priceUsd: order.priceUsd,
+            feeUsd,
+        };
+    }
+    async getPrice(symbol) {
+        return this.prices[symbol] ?? null;
+    }
+}