@hyperscale0/hsx 1.0.258 → 1.0.284

package/dist/src/compile.js

@@ -135,6 +135,24 @@ const camel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 const automatic = (actor) => actor === "clock" ||
     (actor !== null && typeof actor === "object" && "parent" in actor);
 const title = (name) => name[0].toUpperCase() + name.slice(1).replaceAll("_", " ");
+/** Parties an instrument names itself: account owners, actors, move endpoints. */
+function namedParties(instrument) {
+    const names = instrument.fields.flatMap((field) => field.type === "account" && typeof field.owner === "string"
+        ? [field.owner]
+        : []);
+    for (const action of Object.values(instrument.actions)) {
+        if (typeof action.actor === "object" && "party" in action.actor)
+            names.push(action.actor.party);
+        for (const move of action.moves) {
+            if (move.economics)
+                names.push(move.economics.sourceParty);
+            for (const endpoint of "from" in move ? [move.from, move.to] : [])
+                if (endpoint.startsWith("party."))
+                    names.push(endpoint.slice(6));
+        }
+    }
+    return names;
+}
 function entries(block) {
     const map = new Map();
     for (const row of block.entries) {
@@ -174,6 +192,8 @@ function text(expr) {
     return fail(expr, "expected a name or literal", "write a single name or literal");
 }
 function decimal(raw, scale, expr) {
+    if (raw.startsWith("-"))
+        fail(expr, "literal cannot be negative", "write a positive value; a move's from and to set its direction");
     const [whole = "", fraction = ""] = raw.split(".");
     if (!/^\d+$/.test(whole) || fraction.length > scale)
         fail(expr, `literal has more than ${scale} decimal places`, `write at most ${scale} decimal places`);
@@ -243,6 +263,8 @@ function literal(expr, expectedType) {
         return expr.value;
     if (expr.kind === "name" && ["true", "false"].includes(expr.value))
         return expr.value === "true";
+    if (expr.kind === "name" && expr.value === "runtime")
+        fail(expr, "this value is fixed when the program compiles, so it cannot be runtime", "write a literal value");
     return fail(expr, "expected a literal", "write a typed constant");
 }
 export function compile(source, options = {}) {
@@ -990,7 +1012,7 @@ export function compile(source, options = {}) {
                             if (bounds &&
                                 (BigInt(String(value)) < BigInt(bounds.minimum) ||
                                     BigInt(String(value)) > BigInt(bounds.maximum)))
-                                fail(v, `${param.key} is outside ${bounds.minimum}..${bounds.maximum}`, "choose a value inside the tunable's bounds");
+                                fail(v, `value is outside ${bounds.minimum}..${bounds.maximum}`, "choose a value inside the tunable's bounds");
                         }
                         catch (error) {
                             if (error instanceof CompileFailure)
@@ -1039,7 +1061,7 @@ export function compile(source, options = {}) {
                 const left = environment.get(constraint.key), right = environment.get(text(rule.args[0]));
                 if (!left || !right)
                     fail(rule, "constraint needs two declared tunables", "name the compared tunables");
-                const numericKind = (expr) => expr.kind === "name" && /^P/.test(expr.value)
+                const numericKind = (expr) => expr.kind === "name" && /^P(?:\d|T)/.test(expr.value)
                     ? "duration"
                     : expr.kind;
                 if (!["money", "number", "percent", "duration"].includes(numericKind(left)) ||
@@ -1106,6 +1128,7 @@ export function compile(source, options = {}) {
                 return lowered;
             };
             const fields = [];
+            const boundaryReceipts = new Map();
             const calculations = [];
             let currentAction;
             let currentActionName;
@@ -1486,6 +1509,38 @@ export function compile(source, options = {}) {
                 actions: Object.create(null),
                 actionOrder: [],
             };
+            const actionTargets = new Set();
+            const collectTargets = (block) => {
+                for (const entry of block.entries)
+                    if (entry.key.startsWith("when "))
+                        collectTargets(asBlock(entry.value));
+                    else if (entry.key === "calculate")
+                        for (const item of entry.value.kind === "list"
+                            ? entry.value.items
+                            : [entry.value]) {
+                            const target = item.kind === "block" ? entries(item).get("target") : undefined;
+                            if (target)
+                                actionTargets.add(String(data(target)));
+                        }
+            };
+            for (const row of decl.body.entries)
+                if (row.key.startsWith("action "))
+                    collectTargets(asBlock(row.value));
+            // Instrument calculations run before every action, create included, so
+            // a fee or split calculates there only on an amount held from create.
+            const heldFromCreate = (amount) => {
+                if (!("field" in amount))
+                    return true;
+                const [root, name, ...rest] = amount.field.split(".");
+                const field = fields.find((item) => item.name === name);
+                return (root === "self" &&
+                    !rest.length &&
+                    !!field &&
+                    !actionTargets.has(name) &&
+                    (!field.optional ||
+                        "value" in field ||
+                        calculations.some((node) => node.target === name)));
+            };
             for (const row of decl.body.entries.filter((e) => e.key.startsWith("action "))) {
                 const name = row.key.slice(7);
                 const selected = (block) => ({
@@ -1744,7 +1799,7 @@ export function compile(source, options = {}) {
                     ...(actionSubject ? { subject: actionSubject } : {}),
                 };
                 authored.set(a, row.value);
-                const actionFeeCalculations = [];
+                const moveCalculations = [];
                 for (const binding of boundaryBindings)
                     if (!a.subject?.adapters.find((entry) => entry.binding === binding)
                         ?.snapshot)
@@ -1775,8 +1830,20 @@ export function compile(source, options = {}) {
                             const op = parts.has("operation")
                                 ? String(data(parts.get("operation")))
                                 : "internal_transfer.create";
-                            if (op === "internal_transfer.reserve" && !parts.has("capture"))
-                                fail(move, "reserve needs a receipt field", "add capture: receipt_name");
+                            if (op === "internal_transfer.reserve" && !parts.has("capture")) {
+                                if (!parts.has("boundary"))
+                                    fail(move, "reserve needs a receipt field", "add capture: receipt_name");
+                                const capture = `${name}Receipt`;
+                                if (fields.some((field) => field.name === capture))
+                                    fail(move, "boundary receipt name is already used", "name each reservation with an explicit capture");
+                                fields.push({ name: capture, type: "text", optional: true });
+                                boundaryReceipts.set(name, capture);
+                                parts.set("capture", {
+                                    kind: "text",
+                                    value: capture,
+                                    span: move.span,
+                                });
+                            }
                             if ((op === "internal_transfer.post" ||
                                 op === "internal_transfer.void") &&
                                 !parts.has("transfer"))
@@ -1890,6 +1957,7 @@ export function compile(source, options = {}) {
                                         fail(move, "split needs 1 to 64 recipients", "name the receiving parties and percentages");
                                     let total = 0;
                                     const pieces = [];
+                                    const perAction = !heldFromCreate(val(amount));
                                     for (const [index, [party, rate]] of shares.entries()) {
                                         const recipient = resolve({
                                             kind: "name",
@@ -1920,8 +1988,12 @@ export function compile(source, options = {}) {
                                         const target = `${name}_${key}_share${index + 1}`;
                                         if (fields.some((f) => f.name === target))
                                             fail(move, "split field name conflicts", "rename the move key");
-                                        fields.push({ name: target, type: "money" });
-                                        calculations.push(index === shares.length - 1 && pieces.length
+                                        fields.push({
+                                            name: target,
+                                            type: "money",
+                                            ...(perAction ? { optional: true } : {}),
+                                        });
+                                        (perAction ? moveCalculations : calculations).push(index === shares.length - 1 && pieces.length
                                             ? {
                                                 target,
                                                 op: "subtract",
@@ -1993,14 +2065,18 @@ export function compile(source, options = {}) {
                                     if (terms.has("seller") === terms.has("buyer"))
                                         fail(fee, "fee needs exactly one paying party", "write seller: 1% or buyer: 1%");
                                     const quoted = terms.get(paidBy);
+                                    // An account the agreement owns holds only what was moved
+                                    // into it, so a charge on top has nothing to come from.
+                                    if (paidBy === "buyer" &&
+                                        fields.some((field) => `self.${field.name}` === transfer.from &&
+                                            field.type === "account" &&
+                                            field.owner === "self"))
+                                        fail(quoted, `a buyer fee cannot come from \`${transfer.from.slice("self.".length)}\`, which holds only the moved amount`, "use a seller fee, which comes out of the held amount");
                                     const rate = quoted.kind === "capped" ? quoted.rate : quoted;
                                     if (rate.kind !== "percent")
                                         fail(rate, "fee rate needs a percentage", "write a percentage such as 1%");
                                     const prefix = `${name}_${key}`;
-                                    // Instrument calculations run at create, before any action
-                                    // input exists, so a fee on an input amount runs with its action.
-                                    const perAction = "field" in transfer.amount &&
-                                        transfer.amount.field.startsWith("input.");
+                                    const perAction = !heldFromCreate(transfer.amount);
                                     const derived = (suffix, label, calculation) => {
                                         const target = prefix + "_" + suffix;
                                         if (fields.some((f) => f.name === target))
@@ -2011,7 +2087,7 @@ export function compile(source, options = {}) {
                                             label,
                                             ...(perAction ? { optional: true } : {}),
                                         });
-                                        (perAction ? actionFeeCalculations : calculations).push({
+                                        (perAction ? moveCalculations : calculations).push({
                                             ...calculation,
                                             target,
                                         });
@@ -2120,8 +2196,8 @@ export function compile(source, options = {}) {
                     else
                         a[key] = data(expr);
                 }
-                if (actionFeeCalculations.length)
-                    a.calculate = [...(a.calculate ?? []), ...actionFeeCalculations];
+                if (moveCalculations.length)
+                    a.calculate = [...(a.calculate ?? []), ...moveCalculations];
                 if (attachmentInfo) {
                     if (attachmentInfo.exposed.has(name)) {
                         if (automatic(a.actor))
@@ -2199,6 +2275,13 @@ export function compile(source, options = {}) {
                 inst.actions[name] = a;
                 inst.actionOrder.push(name);
             }
+            for (const action of Object.values(inst.actions))
+                for (const move of action.moves)
+                    if ("transfer" in move) {
+                        const receipt = boundaryReceipts.get(move.transfer.replace(/^self\./, ""));
+                        if (receipt)
+                            move.transfer = `self.${receipt}`;
+                    }
             if (attachmentInfo && !attachmentInfo.child)
                 applyAttachmentEconomics(document, inst, attachmentInfo.parties, attachmentInfo.economics, data);
             for (const key of [
@@ -2403,6 +2486,17 @@ export function compile(source, options = {}) {
                     bindingDiagnostics.push(error.diagnostic);
                     continue;
                 }
+                // A business the instrument names itself binds like a parameter, so
+                // Build asks for it and the engine resolves its account and principal.
+                // programOperator and programTax are the company's own accounts.
+                for (const party of document.instruments
+                    .slice(firstAttachedInstrument)
+                    .flatMap(namedParties))
+                    if (document.parties[party]?.kind === "business" &&
+                        party !== "programOperator" &&
+                        party !== "programTax" &&
+                        !Object.values(parties).some((binding) => "party" in binding && binding.party === party))
+                        parties[party] ??= { party };
                 const attachedInst = document.instruments.find((i) => i.id === instId);
                 for (const createdInst of document.instruments
                     .slice(firstAttachedInstrument)