openalgo-script 0.1.0-alpha.1 → 0.2.0

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

@@ -0,0 +1,114 @@
+/**
+ * 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 class Positions {
+    held = new Map();
+    next = 1;
+    /**
+     * 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) {
+        return this.held.get(ref)?.size ?? 0;
+    }
+    /** A fresh position, for the replacement half of a flip. */
+    mint() {
+        const ref = this.next;
+        this.next += 1;
+        this.held.set(ref, { size: 0, cost: 0 });
+        return ref;
+    }
+    /** Step 6 of the fold: `units` at `price` settle against one position. */
+    settle(ref, units, price) {
+        const position = this.held.get(ref) ?? { size: 0, cost: 0 };
+        this.held.set(ref, position);
+        const before = position.size;
+        if (before === 0 || Math.sign(units) === Math.sign(before)) {
+            position.size = before + units;
+            position.cost += units * price;
+        }
+        else {
+            const average = position.cost / before;
+            const after = before + units;
+            position.size = after;
+            // A destination that filled more than the order asked takes the leg
+            // through zero. The remainder is a position in the other direction and it
+            // opened at this fill's price, which is the truthful reading of what the
+            // account now holds. Dropping it would leave the strategy blind to a
+            // position it is carrying.
+            const held = Math.sign(after) === Math.sign(before) ? average : price;
+            position.cost = after === 0 ? 0 : after * held;
+        }
+    }
+    /** The leg's net position in units, `0` while flat. */
+    size() {
+        let total = 0;
+        for (const position of this.held.values())
+            total += position.size;
+        return total;
+    }
+    /**
+     * 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() {
+        const net = this.size();
+        if (net === 0)
+            return null;
+        const side = Math.sign(net);
+        let size = 0;
+        let cost = 0;
+        for (const position of this.held.values()) {
+            if (Math.sign(position.size) !== side)
+                continue;
+            size += position.size;
+            cost += position.cost;
+        }
+        return size === 0 ? null : cost / size;
+    }
+}
+//# sourceMappingURL=positions.js.map

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

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

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

@@ -0,0 +1,43 @@
+import type { Diagnostic } from '../../diagnostics/index.js';
+import type { OrderCall } from './call.js';
+import type { OrderSide } from './intent.js';
+import type { MappedOrder, PlacingContext } from './place.js';
+/**
+ * An order this bar has already sent, which is what OS7013 is asked about.
+ *
+ * The bar's own record, and the only rule left that is scoped to a bar: two
+ * opposite orders on one leg on one bar are refused because which of them to
+ * honour has no defensible answer, and that question is about one bar's
+ * decision rather than about what the destination still has. What a close is
+ * measured against is a different question with a different scope, and it is
+ * answered from the ledger's rows (`closable.ts`).
+ *
+ * The record is the bar's rather than the execution's, so a bar declared
+ * `onUnconfirmed` and executed again is still one bar for it: the orders of its
+ * earlier executions really were handed over.
+ */
+export interface SentOnBar {
+    readonly name: string;
+    readonly line: number;
+    readonly side: OrderSide;
+}
+/**
+ * What the call itself is wrong about, before anything is computed from it.
+ *
+ * Four refusals. Three are about what the script wrote and nothing else, so
+ * they are the same on every bar and on every host. The fourth, OS7017, is the
+ * one quantity a script writes that is a claim about the leg rather than about
+ * itself, so it is answered here, against the leg, before the call is mapped:
+ * a close whose stated quantity is refused has to send nothing at all, and a
+ * close that flattens a tag on a leg holding nothing else maps to no order for
+ * the mapping to refuse.
+ */
+export declare function refusalInCall(call: OrderCall, ctx: PlacingContext): Diagnostic | undefined;
+/**
+ * What one order this call produced is wrong about.
+ *
+ * Asked of every order a call sends, before any of them is given an id, so a
+ * call that sends two sends both or neither.
+ */
+export declare function refusalInOrder(call: OrderCall, order: MappedOrder, ctx: PlacingContext, sent: readonly SentOnBar[]): Diagnostic | undefined;
+//# sourceMappingURL=refuse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refuse.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/refuse.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAa,cAAc,EAAE,MAAM,YAAY,CAAC;AAGzE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AA6ID;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAmC1F;AAsGD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB,UAAU,GAAG,SAAS,CAKxB"}

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

@@ -0,0 +1,329 @@
+/**
+ * What the order layer will not do, `errors.md` OS7002 to OS7013 and OS7017.
+ *
+ * **An order is the one place in the language where doing nothing quietly is
+ * worse than stopping loudly** (`language.md` 6.8). Every refusal here replaced
+ * one of two silences: a call that returned an empty list, so the script was
+ * told nothing and nothing was sent, or a value the engine filled in for itself
+ * and sent to a venue. The second is the worse of the two, because the order
+ * that arrives is a number nobody wrote.
+ *
+ * **A refusal happens before anything is sent.** The ledger asks this file
+ * about every order a call produces, and mints an id for none of them until all
+ * of them have passed, so a refused call reaches no destination at all rather
+ * than being sent and then reported. That is also why the bar stops: a runtime
+ * error stops the bar and marks the script as errored (`errors.md` section 2),
+ * and a strategy that carried on past an order it could not place would be
+ * trading a position it does not believe it has.
+ *
+ * **What is not refused here.** A rule this file cannot evaluate truthfully is
+ * not evaluated at all, because a refusal with a wrong number in it is worse
+ * than the silence it replaced:
+ *
+ * - **A quantity that is not a whole number of lots, OS7005**, and **an order
+ *   outside the instrument's session, OS7012**: both are facts the leg would
+ *   have to be given and neither is one the ledger holds today.
+ * - **A stated close quantity, OS7017, held against a position that is still
+ *   there, where the declaration counts in anything but units.** The refusal
+ *   compares what the script stated with what the leg holds, and a position is
+ *   folded from filled quantities while a stated quantity is in the
+ *   declaration's own unit (`host-interface.md` 7.1). In lots, cash or equity
+ *   percent those are two different kinds of number, and the lot size that
+ *   would join them is the same fact OS7005 is waiting for. **The half of it
+ *   that needs no conversion is evaluated in every unit**: nothing left to
+ *   close is zero in units, in lots, in cash and in an equity percent alike, so
+ *   a close that states a quantity against a part holding nothing is refused
+ *   whatever the declaration counts in. What is left unheld is one shape, a
+ *   stated quantity larger than a position that is still there, and OS7017's
+ *   entry says so where a reader meets it.
+ * - **The capital a strategy has left, OS7011.** Every money figure of
+ *   `stdlib.md` 17.4 is planned, so there is no equity to compare against and a
+ *   number invented for the message would be the wrong one.
+ * - **OS7014 and OS7015 are the host's**, under `host-interface.md` 7.6. A
+ *   destination's own refusal arrives as a frame and is folded onto the row's
+ *   rejection text (17.8), where `order.rejection` reads it; raising it would
+ *   stop a run the fold says continues.
+ */
+import { diagnosticFor } from '../../diagnostics/index.js';
+import { closable } from './closable.js';
+import { isTerminal } from './row.js';
+/**
+ * How a message names an instrument the host gave no symbol for.
+ *
+ * The same words the engine uses for the same gap elsewhere, because a reader
+ * meeting both should not have to work out that they mean one thing.
+ */
+const UNNAMED_INSTRUMENT = "the chart's instrument";
+/** The calls that take the declaration's size when they are given none. */
+const SIZED_BY_DECLARATION = ['buy', 'sell', 'order.place'];
+function nameOf(instrument) {
+    return instrument.symbol ?? UNNAMED_INSTRUMENT;
+}
+/** An order call as a message names one: what was called, and where. */
+function spell(name, line) {
+    return `${name}() on line ${line}`;
+}
+/** What a close is closing, as a message names it: the leg, or one tag of it. */
+function partOf(tag) {
+    return tag === null ? 'the leg' : `the tag "${tag}"`;
+}
+/**
+ * The price argument a named type needs and was not given, `stdlib.md` 17.2.
+ *
+ * Only a call that names a type can disagree with its own prices. `buy` and
+ * `sell` take no type and their prices imply one, so the two always agree.
+ */
+function priceMissing(call) {
+    const type = call.type;
+    if ((type === 'limit' || type === 'stopLimit') && call.limit === null)
+        return 'price';
+    if ((type === 'stop' || type === 'stopLimit') && call.trigger === null)
+        return 'trigger';
+    return undefined;
+}
+/**
+ * Whether a price falls on a tick.
+ *
+ * Compared as a count of ticks with a tolerance, because a price computed from
+ * a tick size rarely divides by it exactly in binary: a level two ticks above
+ * a close is the right price and the division that reads it back is not exact.
+ * A tolerance relative to the count keeps that true at every magnitude, and it
+ * is far tighter than half a tick, which is what would be needed to let a price
+ * between two ticks through.
+ */
+function onTick(price, tick) {
+    const steps = price / tick;
+    const nearest = Math.round(steps);
+    return Math.abs(steps - nearest) <= 1e-9 * Math.max(1, Math.abs(steps));
+}
+/**
+ * The entries already open in one direction, which is what pyramiding counts.
+ *
+ * `language.md` 13.3 says entries in one **direction**, and the message says
+ * the strategy already holds them, so the count is over every position the leg
+ * still holds on that side rather than over one of them. The two were the same
+ * number while every entry in a direction shared one reference, and they are
+ * not any more: an entry placed while the whole of a position is on its way out
+ * opens a position of its own (`holdings.ts`), so a count keyed to a single
+ * reference would report none and let a declaration of one entry hold two.
+ *
+ * **A position the leg no longer holds is not counted.** A reference ends when
+ * its quantity returns to zero through settled fills (`stdlib.md` 17.7), and
+ * the entries that made it up ended with it.
+ *
+ * **An order that has not filled is not an open entry**, and the count says so
+ * because the code's own fix says so: OS7008 tells a reader to test `pos.size`,
+ * and `pos.size` is folded from settled fills and from nothing else
+ * (`stdlib.md` 17.1). A count that included an order still waiting at the venue
+ * would refuse a script that had done exactly what the fix asked, which is the
+ * one thing a fix may never do.
+ */
+function entriesOpen(ctx, side) {
+    const holding = side === 'buy' ? 1 : -1;
+    let found = 0;
+    for (const row of ctx.rows()) {
+        if (row.side !== side || row.filledQty === 0)
+            continue;
+        if (Math.sign(ctx.sizeOf(row.positionRef)) !== holding)
+            continue;
+        found += 1;
+    }
+    return found;
+}
+/**
+ * A close asked to send more than it is closing, OS7017.
+ *
+ * **No order crosses zero** (`stdlib.md` 17.1), and a quantity the script
+ * stated was passed through as written, so `close(qty = 5)` against one unit
+ * long sent one sell of five and the leg ended the bar four short, under one
+ * position reference, with a call named close having opened a position.
+ *
+ * **What it is held against is what is left to close**, which `closable.ts`
+ * answers: what the part holds, less everything already working against it.
+ * Held against the leg alone, `close(qty = 2)` twice on a leg of three passed
+ * twice and the leg ended one short, each order inside the ceiling and the pair
+ * outside it; and `close(qty = 3)` on the bar after one whose close of three was
+ * still at the destination passed as well, for the same reason one scope out.
+ *
+ * **Refused rather than clamped**, because the quantity is an argument the
+ * script wrote and is therefore a claim about the strategy's own position.
+ * Sending what is there would leave the script believing it closed the number
+ * it asked for, which is the wrong-belief class OS7002, OS7004 and OS7016 each
+ * already refuse. Reading it as a reversal would make `close` open a position.
+ *
+ * **What this does not touch.** A close that states no quantity works the
+ * number out itself and is unchanged, whether the leg is flat, the tag has
+ * already flattened or its entry has not fired yet: that is the idempotence of
+ * `stdlib.md` 17.2 and a refusal keyed on it would break the shape a strategy
+ * is written in. The two look inconsistent beside each other and are not. The
+ * call with a quantity makes a claim, and the claim is checkable; the call
+ * without one asks the engine for the right number, and there is nothing to be
+ * wrong about.
+ *
+ * **In full only where the two numbers count the same thing, and in part
+ * everywhere.** See the header: a declaration in lots, cash or equity percent
+ * states a quantity the ledger cannot compare with a folded position, and a
+ * refusal with a wrong number in it is worse than the silence it replaced. But
+ * nothing left to close is zero in every one of those units, and a close of any
+ * quantity against nothing is a false claim whatever the unit, so that half is
+ * answered for every declaration rather than for one of them.
+ */
+function beyondTheClose(call, ctx) {
+    if (call.name !== 'close')
+        return undefined;
+    const stated = call.qty;
+    if (stated === null)
+        return undefined;
+    const left = closable(ctx, call.tag);
+    const held = left.units;
+    if (stated <= held)
+        return undefined;
+    // Outside units the two numbers count different things, and the one thing
+    // they agree on is nothing at all. An assumed zero is not a measurement, so
+    // it is not named in a message either.
+    if (ctx.qtyType !== 'units' && !(held === 0 && left.counted))
+        return undefined;
+    return diagnosticFor('OS7017', call.at, { qty: stated, part: partOf(call.tag), held });
+}
+/**
+ * What the call itself is wrong about, before anything is computed from it.
+ *
+ * Four refusals. Three are about what the script wrote and nothing else, so
+ * they are the same on every bar and on every host. The fourth, OS7017, is the
+ * one quantity a script writes that is a claim about the leg rather than about
+ * itself, so it is answered here, against the leg, before the call is mapped:
+ * a close whose stated quantity is refused has to send nothing at all, and a
+ * close that flattens a tag on a leg holding nothing else maps to no order for
+ * the mapping to refuse.
+ */
+export function refusalInCall(call, ctx) {
+    // OS7002. Every argument the script wrote that came out absent, named in
+    // signature order, so a call with two is reported on the first one a reader
+    // would fix. An argument the script did not write is not one of them: it
+    // takes the default `stdlib.md` documents, and `call.ts` says how the two are
+    // told apart.
+    const absent = call.absent[0];
+    if (absent !== undefined) {
+        return diagnosticFor('OS7002', call.at, { name: call.name, argument: absent });
+    }
+    // OS7004. Direction is chosen by the function and not by the sign, so a
+    // negative quantity is a calculation that went the wrong way.
+    const stated = call.qty;
+    if (stated !== null && !(stated > 0)) {
+        return diagnosticFor('OS7004', call.at, { name: call.name, qty: stated });
+    }
+    // The declaration's own size, on a call that names none and would take it.
+    if (stated === null && SIZED_BY_DECLARATION.includes(call.name) && !(ctx.declaredQty > 0)) {
+        return diagnosticFor('OS7004', call.at, { name: call.name, qty: ctx.declaredQty });
+    }
+    // OS7017. After OS7004, so a negative quantity is still answered by the code
+    // that is about the sign rather than by the one that is about the size.
+    const crossing = beyondTheClose(call, ctx);
+    if (crossing !== undefined)
+        return crossing;
+    // OS7007. Filling the price in from the bar's close would make the order a
+    // market order wearing another name.
+    const missing = priceMissing(call);
+    if (missing !== undefined && call.type !== null) {
+        return diagnosticFor('OS7007', call.at, { type: call.type, argument: missing });
+    }
+    return undefined;
+}
+/** A cancellation naming an order that is not there to cancel, OS7009. */
+function unknownTag(call, placement, ctx) {
+    for (const row of ctx.rows()) {
+        if (row.tag === placement.tag && !isTerminal(row.status))
+            return undefined;
+    }
+    return diagnosticFor('OS7009', call.at, { tag: placement.tag });
+}
+/**
+ * A protective level on the wrong side of the entry, OS7010.
+ *
+ * Only against a position that is open, because the level is measured from the
+ * position's average entry price and a leg that holds nothing has none. An
+ * entry and its bracket on one bar is the common shape and is not this case:
+ * the entry has not filled, so there is nothing yet for the level to be on the
+ * wrong side of, which is why a bracket may also state its levels as distances.
+ *
+ * A level exactly at the entry is not refused. Moving every stop to its own
+ * entry is a rule the language names (`stdlib.md` 17.11), so the price that
+ * rule produces cannot be one the language will not take.
+ */
+function wrongSide(call, placement, ctx) {
+    const entry = ctx.avgPrice();
+    const size = ctx.size();
+    if (entry === null || size === 0)
+        return undefined;
+    const long = size > 0;
+    const side = long ? 'long' : 'short';
+    const stop = placement.stop;
+    if (stop !== null && (long ? stop > entry : stop < entry)) {
+        return diagnosticFor('OS7010', call.at, { side, entry, leg: 'stop', price: stop });
+    }
+    const target = placement.target;
+    if (target !== null && (long ? target < entry : target > entry)) {
+        return diagnosticFor('OS7010', call.at, { side, entry, leg: 'limit', price: target });
+    }
+    return undefined;
+}
+/** What one order is wrong about, given the instrument and the leg. */
+function ordering(call, order, ctx, sent) {
+    const placement = order.placement;
+    const side = placement.side;
+    if (side === null)
+        return undefined;
+    // OS7006. A price between two ticks cannot exist at the exchange, and
+    // rounding it here would move the order off the level the script computed.
+    const tick = ctx.tickSize;
+    if (tick !== null && tick > 0) {
+        for (const price of [placement.limit, placement.trigger]) {
+            if (price === null || onTick(price, tick))
+                continue;
+            return diagnosticFor('OS7006', call.at, { symbol: nameOf(ctx.instrument), tick, price });
+        }
+    }
+    // OS7008. Refusing rather than silently adding keeps a backtest from building
+    // a position the declaration forbade.
+    //
+    // **Whether this order is an entry is the mapping's answer, not the leg's
+    // net.** The net is folded from settled fills, so it reads flat while an
+    // entry is still going and called every order an entry, and it reads long
+    // while a leg is being flipped and called neither half of the flip one. The
+    // mapping has already divided the call into what comes off a position the leg
+    // holds and what opens one, and an order that comes off a position is not an
+    // entry whatever the net says.
+    if (order.reduces === null) {
+        const found = entriesOpen(ctx, side);
+        if (found >= ctx.pyramiding) {
+            return diagnosticFor('OS7008', call.at, { max: ctx.pyramiding, found });
+        }
+    }
+    // OS7013. Which of the two to honour has no defensible answer, so neither is
+    // placed: this call sends nothing, and the bar stops before anything the bar
+    // decided reaches the destination.
+    const opposite = sent.find((one) => one.side !== side);
+    if (opposite !== undefined) {
+        return diagnosticFor('OS7013', call.at, {
+            first: spell(opposite.name, opposite.line),
+            second: spell(call.name, call.at.line),
+            bar: ctx.bar.index,
+        });
+    }
+    return undefined;
+}
+/**
+ * What one order this call produced is wrong about.
+ *
+ * Asked of every order a call sends, before any of them is given an id, so a
+ * call that sends two sends both or neither.
+ */
+export function refusalInOrder(call, order, ctx, sent) {
+    const placement = order.placement;
+    if (placement.kind === 'cancel')
+        return unknownTag(call, placement, ctx);
+    if (placement.kind === 'bracket')
+        return wrongSide(call, placement, ctx);
+    return ordering(call, order, ctx, sent);
+}
+//# sourceMappingURL=refuse.js.map

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

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