openalgo-script 0.1.0-alpha.1 → 0.2.0

package/dist/core/engine/ledger/ledger.js

@@ -0,0 +1,237 @@
+import { callOf } from './call.js';
+import { intentFor, ordersFor } from './place.js';
+import { Positions } from './positions.js';
+import { refusalInCall, refusalInOrder } from './refuse.js';
+import { foldFrame } from './row.js';
+export class Ledger {
+    byIntent = new Map();
+    placed = [];
+    positions = new Positions();
+    waiting = [];
+    next = 1;
+    options;
+    /** The bar `sent` describes, so the list empties when a new one begins. */
+    at = -1;
+    /**
+     * The orders this bar has sent, which is what OS7013 is asked about.
+     *
+     * The bar is the right scope for that one rule and for nothing else. What a
+     * reducing order is measured against used to be read from here too, and the
+     * defect that made obvious was the plainest one there is: a close still
+     * working when the next bar closed again was invisible, because this list is
+     * emptied the moment the bar index changes. The rows below outlive the bar
+     * and say which orders the destination still has, so that reading moved to
+     * `closable.ts` and this list kept the question that really is a bar's.
+     */
+    sent = [];
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Step 9 sent an order call. It becomes intents, and each becomes a row.
+     *
+     * A row is appended when the order is sent, at `placed`, which is the
+     * engine's own status: an intent has left and nothing has come back, and a
+     * host cannot report a state the destination has never described.
+     *
+     * **The whole call is read, mapped and refused before any of it is sent.**
+     * Every order the call produces is held against `refuse.ts` first, and only
+     * then does any of them take an id, so a refused call appends no row and
+     * returns no intent: there is nothing for a host to send and nothing to take
+     * back afterwards. A call that sends two orders sends both or neither.
+     *
+     * **The bar is the same promise one scope up**, and `discard` below is how
+     * it is kept. A refusal anywhere on a bar hands none of the bar's orders to a
+     * destination, so none of the bar's rows may survive it either, including the
+     * rows of calls that had already been mapped when the refusal happened. That
+     * is not the ledger rewriting a record backwards: nothing was handed over, so
+     * there is no record of a hand-over to rewrite.
+     */
+    place(name, params, args, bar, at) {
+        if (bar.index !== this.at) {
+            this.at = bar.index;
+            this.sent = [];
+        }
+        const ctx = this.contextFor(bar);
+        const call = callOf(name, params, args, at);
+        const refused = refusalInCall(call, ctx);
+        if (refused !== undefined)
+            return { intents: [], refusal: refused };
+        const orders = ordersFor(call, ctx);
+        for (const order of orders) {
+            const bad = refusalInOrder(call, order, ctx, this.sent);
+            if (bad !== undefined)
+                return { intents: [], refusal: bad };
+        }
+        const intents = [];
+        for (const order of orders) {
+            const intentId = this.next;
+            this.next += 1;
+            const intent = intentFor(order.placement, intentId, ctx);
+            intents.push(intent);
+            // Only an order that places one appends a row: a cancellation and a
+            // bracket carry an id a host can quote and nothing has been ordered by
+            // either. What a cancellation does to an order, and what a bracket's
+            // level does when it is reached, both arrive as frames about orders.
+            const { side, qty, type } = intent;
+            if (intent.kind === 'place' && side !== null && qty !== null && type !== null) {
+                // What the order takes out of the position rides on the row, because
+                // the row is what outlives the bar: an order the destination has not
+                // answered is still going, and the row is the only record of it.
+                this.append(intent, { side, qty, type }, bar, order.reduces);
+                // One entry per appended row, in the same order, which is what lets a
+                // refused bar take back exactly the orders it appended.
+                this.sent.push({ name: call.name, line: at.line, side });
+            }
+        }
+        return { intents, refusal: undefined };
+    }
+    /**
+     * The bar sent nothing after all: every row it appended is taken back.
+     *
+     * A refusal anywhere on a bar hands none of the bar's orders over, because
+     * every call is mapped before any of them is routed (`orders.ts`). Until this
+     * existed, the rows of the calls that had already been mapped stayed: a bar
+     * that placed an order and then met a refusal left `orders()` reporting an
+     * order at `placed` that no destination was ever handed, and a host
+     * reconciling after a stopped run saw an order it never received. 17.7 says a
+     * row is appended when the order is sent, and nothing had been sent.
+     *
+     * **Taken back rather than never written.** A row has to be there while the
+     * rest of the bar is mapped: `cancel` asks whether a tag names a working
+     * order, pyramiding counts the entries a position already holds, and a close
+     * measures what one tag entered, all from rows this same bar may have
+     * appended. Deferring the append would make an entry and a cancellation of it
+     * on one bar into OS7009. So the bar writes its rows and a refused bar undoes
+     * them, which is the same shape the moving bar already uses on the cells.
+     *
+     * The intent ids the bar minted are not reissued. An id is unique within a
+     * run (`stdlib.md` 17.7), a frame that quoted one must never match a later
+     * order, and a gap in the numbering is invisible to a host, so the cheap
+     * invariant is the one worth keeping.
+     *
+     * **`from` is the row count the routing pass began at**, and it is held by
+     * that pass rather than by a bar index kept here. A bar declared
+     * `onUnconfirmed` applies its effects on every execution of itself, so one bar
+     * can route more than once, and a mark taken when the bar index last changed
+     * would take back rows whose orders a previous execution really did hand over.
+     * The promise belongs to the pass that made it, so the mark does too.
+     */
+    discard(from) {
+        const dropped = this.placed.length - from;
+        if (dropped <= 0)
+            return;
+        for (const row of this.placed.slice(from))
+            this.byIntent.delete(row.intentId);
+        this.placed.length = from;
+        // One row appended pushed exactly one entry here, in the same order, so the
+        // orders OS7013 has seen this bar shrink by the same count.
+        this.sent.length = Math.max(0, this.sent.length - dropped);
+    }
+    /** A frame from the destination, held until the next bar boundary. */
+    deliver(frame) {
+        this.waiting.push(frame);
+    }
+    /**
+     * Folds every frame that has arrived, in the order it arrived in.
+     *
+     * A host does not have to put its frames in order before it sends them. A
+     * repeat, a pair that crossed in flight and one that arrives after the order
+     * ended are ordinary traffic, and the fold is what says what each of them
+     * does.
+     */
+    settle() {
+        if (this.waiting.length === 0)
+            return [];
+        const frames = this.waiting;
+        this.waiting = [];
+        const outcomes = [];
+        for (const frame of frames) {
+            const row = this.byIntent.get(frame.intentId);
+            if (row === undefined) {
+                // Step 1. It is not an order this strategy placed. Refused and
+                // recorded, and nothing is folded.
+                outcomes.push({
+                    intentId: frame.intentId,
+                    refused: 'unknownIntent',
+                    changed: false,
+                    delta: 0,
+                    price: null,
+                    afterTerminal: false,
+                });
+                continue;
+            }
+            const outcome = foldFrame(row, frame);
+            // Step 6, and the reason the row carries a position reference: the fill
+            // settles the position that order belongs to and not whichever position
+            // the leg holds now.
+            if (outcome.delta > 0 && outcome.price !== null) {
+                const units = row.side === 'buy' ? outcome.delta : -outcome.delta;
+                this.positions.settle(row.positionRef, units, outcome.price);
+            }
+            outcomes.push(outcome);
+        }
+        return outcomes;
+    }
+    /** The leg's net position in units, `0` while flat. */
+    size() {
+        return this.positions.size();
+    }
+    /** The average price of the open position, absent while flat. */
+    avgPrice() {
+        return this.positions.avgPrice();
+    }
+    /** Every row, oldest first, for a host that reports what the run did. */
+    rows() {
+        return this.placed;
+    }
+    append(intent, order, bar, reduces) {
+        const row = {
+            intentId: intent.intentId,
+            orderRef: '',
+            tag: intent.tag,
+            // The only leg has no name of its own: a name comes from a leg
+            // declaration, and those are planned (`stdlib.md` 17.6).
+            leg: '',
+            positionRef: intent.positionRef,
+            instrument: intent.instrument,
+            product: intent.product,
+            side: order.side,
+            qty: order.qty,
+            type: order.type,
+            price: intent.limit,
+            trigger: intent.trigger,
+            status: 'placed',
+            filledQty: 0,
+            avgFillPrice: null,
+            rejection: '',
+            placedAt: bar.time,
+            updatedAt: bar.time,
+            reduces,
+            // What this order puts into its position, in units, where the engine can
+            // read it. `qtyType` is the unit `qty` is counted in and is per order
+            // rather than per run, so a quantity the engine worked out is readable
+            // in a declaration whose own unit is not (`host-interface.md` 7.1).
+            units: intent.qtyType === 'units' ? order.qty : null,
+        };
+        this.placed.push(row);
+        this.byIntent.set(row.intentId, row);
+    }
+    contextFor(bar) {
+        return {
+            instrument: this.options.instrument,
+            product: this.options.product,
+            qtyType: this.options.qtyType,
+            declaredQty: this.options.declaredQty,
+            tickSize: this.options.tickSize,
+            pyramiding: this.options.pyramiding,
+            bar,
+            size: () => this.positions.size(),
+            sizeOf: (ref) => this.positions.sizeOf(ref),
+            avgPrice: () => this.positions.avgPrice(),
+            mint: () => this.positions.mint(),
+            rows: () => this.placed,
+        };
+    }
+}
+//# sourceMappingURL=ledger.js.map

package/dist/core/engine/ledger/ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.js","sourceRoot":"","sources":["../../../../src/core/engine/ledger/ledger.ts"],"names":[],"mappings":"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"}

package/dist/core/engine/ledger/place.d.ts

@@ -0,0 +1,75 @@
+/**
+ * One order call becomes one or more intents, `stdlib.md` 17.2 and 17.3.
+ *
+ * **This file says what a call means; `sizing.ts` says how much it sends and
+ * against which position.** The two were one file until the second question
+ * arrived: how many orders a call becomes, how large each of them is and which
+ * position reference each one carries is arithmetic over what the leg holds, and
+ * it is long enough written down to crowd out the vocabulary of the calls. The
+ * sentences below about the split are still this file's, because they are why
+ * the calls mean what they mean.
+ *
+ * **Every order states its own side and its own quantity outright.** Nothing
+ * here computes a delta against an account position, for the reason 17.1 gives:
+ * an account position is held per contract, so a second strategy, a manual
+ * trade or this same script started twice all land in that one row, and an
+ * order sized against it is sized against somebody else's trade.
+ *
+ * What a flattening order does compute against is the strategy's **own**
+ * position, folded from its own settled fills, which is a different number with
+ * a different owner.
+ *
+ * **No order crosses zero.** An instruction that would take a leg from long to
+ * short is two orders, one closing the outgoing position and one opening the
+ * replacement, each carrying its own position reference, so that a fill
+ * arriving late can still say which of the two it settled. That is the split
+ * `entering` makes, and `order.reverse` is the same pair written as one call.
+ *
+ * **A reducing order is sized against what is available to reduce**, which is
+ * the settled position less everything already working against it. A position
+ * is folded from settled fills and from nothing else (`stdlib.md` 17.8), so an
+ * order the destination has not answered has filled nothing and has moved no
+ * position figure: measured against the leg alone, a second close sends the
+ * whole of it again, on the same bar and on every bar after it, and the leg
+ * ends short with no quantity written anywhere. `closableUnits` answers it and
+ * the ledger's own rows are where it is read from.
+ *
+ * **A bracket is an instruction, not an order.** `exit` and `order.bracket` set
+ * the leg's own protective level, which is what `stdlib.md` 17.2 means when it
+ * says a leg carries at most one stop and at most one target at a time. The tag
+ * they take defaults to the empty string and rides along as a label, for the
+ * destination and the report. It is not a reference to an order that has to
+ * exist, so a bracket naming a tag nothing was ever placed with is an ordinary
+ * call and is not refused: the level it sets belongs to the leg either way, and
+ * `refuse.ts` measures it from the leg's own average entry price. They send an
+ * intent so that a host has something to act on, and they append no ledger row
+ * and move no position, because nothing has been ordered until the level is
+ * reached.
+ *
+ * **A tag on a call that flattens is the other kind.** `close`'s tag defaults to
+ * absence rather than to the empty string, and it names the part of the position
+ * that tag entered, which is a reference to rows this ledger holds. A tag no
+ * order in the file can place is OS7016, at the call, before any bar runs.
+ *
+ * **Nothing here refuses anything.** This file says what a call means; `refuse.ts`
+ * says what the language will not do, and the ledger asks it first. The two were
+ * one file once, and what that produced was a call whose quantity did not make
+ * sense returning an empty list: no order, no refusal, and a script that had
+ * been told nothing.
+ */
+import type { OrderCall } from './call.js';
+import type { OrderIntent } from './intent.js';
+import type { MappedOrder, Placement, PlacingContext } from './sizing.js';
+export type { MappedOrder, Placement, PlacingContext } from './sizing.js';
+/**
+ * The orders one call sends, in the order it sends them.
+ *
+ * A call that has nothing to send sends nothing: flattening a leg that holds
+ * nothing and reversing a position that does not exist are both instructions
+ * about a position the strategy does not hold, and inventing a side for either
+ * would be the engine deciding a direction the script never stated.
+ */
+export declare function ordersFor(call: OrderCall, ctx: PlacingContext): readonly MappedOrder[];
+/** The intent one placement becomes, `host-interface.md` 7.1. */
+export declare function intentFor(placement: Placement, intentId: number, ctx: PlacingContext): OrderIntent;
+//# sourceMappingURL=place.d.ts.map

package/dist/core/engine/ledger/place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/place.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AAI1D,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE1E,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAuE1E;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,cAAc,GAAG,SAAS,WAAW,EAAE,CAmHtF;AAED,iEAAiE;AACjE,wBAAgB,SAAS,CACvB,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,cAAc,GAClB,WAAW,CAQb"}

package/dist/core/engine/ledger/place.js

@@ -0,0 +1,174 @@
+import { closableUnits, closingFor, closingSide } from './closable.js';
+import { protecting } from './holdings.js';
+import { isTerminal } from './row.js';
+import { NOTHING, adding, entering, flattening } from './sizing.js';
+/**
+ * The type the prices imply.
+ *
+ * Stated on the intent rather than left to the host, so a destination never has
+ * to infer it: with neither price a market order, with a limit alone a limit
+ * order, with a trigger alone a stop order, and with both a stop limit order
+ * (`stdlib.md` 17.2).
+ */
+function typeOf(limit, trigger) {
+    if (limit !== null && trigger !== null)
+        return 'stopLimit';
+    if (limit !== null)
+        return 'limit';
+    if (trigger !== null)
+        return 'stop';
+    return 'market';
+}
+/**
+ * A cancellation names the tag it cancels and nothing else.
+ *
+ * No side, no quantity and no price: it is not an order, and what becomes of
+ * the order it names arrives as a frame about that order.
+ */
+function cancelling(tag) {
+    return { ...NOTHING, kind: 'cancel', tag, positionRef: 0 };
+}
+/** A protective level attached to a tag, `stdlib.md` 17.2 and 17.3. */
+function bracketing(ctx, tag, qty, target, stop, profit, loss) {
+    // A call that names no level at all removes one, which is a standing level of
+    // `stdlib.md` 17.9 and is planned. There is nothing to send.
+    if (target === null && stop === null && profit === null && loss === null)
+        return [];
+    // Nothing has been ordered by a bracket, so it takes nothing out of the
+    // position: the level it sets belongs to the leg until it is reached.
+    return [
+        adding({
+            ...NOTHING,
+            kind: 'bracket',
+            qty,
+            qtyType: qty === null ? 'units' : ctx.qtyType,
+            target,
+            stop,
+            profit,
+            loss,
+            tag,
+            // The position the level protects, and zero where the leg holds none,
+            // which is the value a cancellation already carries for the same reason:
+            // neither is an order and neither has a position of its own. Minting one
+            // here burned a reference on an instruction that moves nothing, so a
+            // script whose first call is `exit()` opened on reference 2 and the
+            // bracket named a reference no order ever carried
+            // (`host-interface.md` 7.1).
+            //
+            // **Asked of the book, because what the leg holds is not what was minted
+            // last.** The reference minted last is cleared when that one reference
+            // returns to zero, so a leg still holding an older position reported none
+            // and a bracket went out carrying `0`, which is the one value 7.1 tells a
+            // host means there is nothing to look up (`holdings.ts`, `protecting`).
+            positionRef: protecting(ctx) ?? 0,
+        }),
+    ];
+}
+/**
+ * The orders one call sends, in the order it sends them.
+ *
+ * A call that has nothing to send sends nothing: flattening a leg that holds
+ * nothing and reversing a position that does not exist are both instructions
+ * about a position the strategy does not hold, and inventing a side for either
+ * would be the engine deciding a direction the script never stated.
+ */
+export function ordersFor(call, ctx) {
+    const side = call.side;
+    switch (call.name) {
+        case 'buy':
+        case 'sell':
+            if (side === null)
+                return [];
+            return entering(ctx, {
+                side,
+                limit: call.limit,
+                trigger: call.trigger,
+                type: typeOf(call.limit, call.trigger),
+                tag: call.tag ?? '',
+            }, call.qty);
+        case 'order.place': {
+            // A side that is not one of the two is not a direction, and a buy is not
+            // the safe guess: the checker refuses a written value outside the set
+            // with OS3008, and a computed one that reaches here sends nothing rather
+            // than sending the opposite of what the script meant. A side the script
+            // stated as absent never reaches here at all: that is OS7002.
+            if (side === null)
+                return [];
+            return entering(ctx, {
+                side,
+                limit: call.limit,
+                trigger: call.trigger,
+                // A type outside the set falls back to the one the prices imply,
+                // which is the correspondence `stdlib.md` 17.2 fixes between the two.
+                type: call.type ?? typeOf(call.limit, call.trigger),
+                tag: call.tag ?? '',
+            }, call.qty);
+        }
+        case 'close': {
+            // **The side comes from the part the call names**, which is the leg only
+            // where it names no tag. Taken from the leg's net, a close of a part
+            // holding four short on a leg netting six long was a sell of four: the
+            // part went to eight short, the other tag's long was cut to six, and a
+            // call named close had opened position (`closable.ts`, `stdlib.md` 17.2).
+            const closing = closingFor(ctx, call.tag);
+            if (closing === undefined)
+                return [];
+            // A tag names the part of the position that tag entered, which is the
+            // settled quantity of its own rows, less what is already working against
+            // it. A quantity the script stated has already been held against this
+            // same number by `refuse.ts`, so nothing reaching here crosses zero.
+            return flattening(ctx, closableUnits(ctx, call.tag), closing, call.qty, call.tag ?? '', call.tag);
+        }
+        case 'order.reverse': {
+            const size = ctx.size();
+            const closing = closingSide(size);
+            if (closing === undefined)
+                return [];
+            const tag = call.tag ?? '';
+            // What is left to close rather than the whole leg, so that a reverse
+            // after a close on the same bar does not send the position twice.
+            const out = flattening(ctx, closableUnits(ctx, null), closing, null, tag, null);
+            // The replacement is a position of its own, minted here, so that a fill
+            // on the outgoing order settles the position it belonged to.
+            const ref = ctx.mint();
+            const opening = {
+                ...NOTHING,
+                kind: 'place',
+                side: closing,
+                qty: call.qty ?? Math.abs(size),
+                qtyType: call.qty === null ? 'units' : ctx.qtyType,
+                type: 'market',
+                tag,
+                positionRef: ref,
+            };
+            return [...out, adding(opening)];
+        }
+        case 'exit':
+            return bracketing(ctx, call.tag ?? '', call.qty, call.target, call.stop, call.profit, call.loss);
+        case 'order.bracket':
+            return bracketing(ctx, call.tag ?? '', null, null, null, call.profit, call.loss);
+        case 'cancel':
+            return [adding(cancelling(call.tag ?? ''))];
+        case 'cancelAll': {
+            const tags = [];
+            for (const row of ctx.rows()) {
+                if (!isTerminal(row.status) && !tags.includes(row.tag))
+                    tags.push(row.tag);
+            }
+            return tags.map((tag) => adding(cancelling(tag)));
+        }
+        default:
+            return [];
+    }
+}
+/** The intent one placement becomes, `host-interface.md` 7.1. */
+export function intentFor(placement, intentId, ctx) {
+    return {
+        ...placement,
+        intentId,
+        instrument: ctx.instrument,
+        product: ctx.product,
+        bar: ctx.bar,
+    };
+}
+//# sourceMappingURL=place.js.map

package/dist/core/engine/ledger/place.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"place.js","sourceRoot":"","sources":["../../../../src/core/engine/ledger/place.ts"],"names":[],"mappings":"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"}

package/dist/core/engine/ledger/positions.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The positions a leg holds, folded from settled fills and from nothing else,
+ * `stdlib.md` 17.1 and 17.7.
+ *
+ * **A fill settles the position its own order names, never whichever position
+ * the leg holds now.** That is what the position reference is for: during a
+ * flip a leg holds two positions at once, the outgoing one and its replacement,
+ * and a fill that arrives late would otherwise be applied to the position that
+ * replaced the one it belonged to.
+ *
+ * **Reducing a position does not move its average price.** The units that leave
+ * leave at the price the position was opened at, so what remains is still the
+ * average of what was bought. An engine that took the closing fill's price into
+ * the average would report an entry at a price nothing was entered at, and
+ * every level measured from the entry would be measured from that.
+ *
+ * Nothing here is money. Realised profit, equity and the trade list are
+ * `stdlib.md` 17.4's planned entries, and this holds the two facts the five
+ * position calls of this release read: how much is held, and at what average.
+ */
+export declare class Positions {
+    private readonly held;
+    private next;
+    /**
+     * The settled size of one position reference, signed the way a position is.
+     *
+     * **Per reference rather than per leg**, because which position an order is
+     * sent against is a question about one position and the leg's net cannot
+     * answer it: a leg holds more than one position whenever an order that
+     * opposes it is outstanding, and two that net to zero are not the same thing
+     * as no position at all. `holdings.ts` reads this beside the ledger's own
+     * rows, which is the division the rest of the engine already keeps: what
+     * settled is the position book's, what is working is the ledger's.
+     *
+     * Zero for a reference this book has never been given a fill for, which is
+     * both a reference minted for an order that has not settled and one that is
+     * not a reference at all.
+     */
+    sizeOf(ref: number): number;
+    /** A fresh position, for the replacement half of a flip. */
+    mint(): number;
+    /** Step 6 of the fold: `units` at `price` settle against one position. */
+    settle(ref: number, units: number, price: number): void;
+    /** The leg's net position in units, `0` while flat. */
+    size(): number;
+    /**
+     * The average price of what the leg holds, absent while flat.
+     *
+     * Absent rather than zero, because zero is a price and a script comparing
+     * against it would take a branch that looks correct (`stdlib.md` 17.4).
+     *
+     * **Averaged over the positions that make up what the leg holds**, which is
+     * the ones on the side of its net, and not over every position open at once.
+     * A leg holds more than one whenever an order that opposes it is outstanding:
+     * during a flip it holds the outgoing position and its replacement, and where
+     * the engine could not size the opposing order against the leg it holds the
+     * position that order opened beside the one it was meant to replace. Summed
+     * across both, the cost of a position on the way out is subtracted from the
+     * cost of the one on the way in, and the quotient is a price nothing was
+     * entered at: three hundred bought at one hundred with two hundred and
+     * twenty five sold at one hundred and ten reported an entry at seventy, and
+     * every level a script measures from the entry would have been measured from
+     * it. Reducing a position does not move its average, and that is the same
+     * sentence read across a leg rather than inside one position.
+     */
+    avgPrice(): number | null;
+}
+//# sourceMappingURL=positions.d.ts.map

package/dist/core/engine/ledger/positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/positions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA2B;IAChD,OAAO,CAAC,IAAI,CAAK;IAEjB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAI3B,4DAA4D;IAC5D,IAAI,IAAI,MAAM;IAOd,0EAA0E;IAC1E,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAsBvD,uDAAuD;IACvD,IAAI,IAAI,MAAM;IAMd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,IAAI,MAAM,GAAG,IAAI;CAa1B"}