@harmoniclabs/pebble 0.3.2 → 0.3.4

package/dist/IR/IRNodes/IRConst.js

@@ -292,6 +292,12 @@ export function tirTypeToUplcType(t) {
     }
     if (t instanceof TirValueT)
         return constT.value;
+    if (t instanceof TirBlsG1T)
+        return constT.bls12_381_G1_element;
+    if (t instanceof TirBlsG2T)
+        return constT.bls12_381_G2_element;
+    if (t instanceof TirMlResultT)
+        return constT.bls12_381_MlResult;
     if (t instanceof TirDataT
         || t instanceof TirDataOptT
         || t instanceof TirDataStructType)
@@ -308,10 +314,7 @@ export function tirTypeToUplcType(t) {
         || t instanceof TirFuncT
         || t instanceof TirSopOptT
         || t instanceof TirSoPStructType
-        || t instanceof TirTypeParam
-        || t instanceof TirBlsG1T
-        || t instanceof TirBlsG2T
-        || t instanceof TirMlResultT)
+        || t instanceof TirTypeParam)
         throw new Error("invalid uplc const type");
     const tsEnsureExsaustiveCheck = t;
     throw new Error("tirTypeToUplcType: unreachable");

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -32,8 +32,30 @@ export class ToUplcCtx {
         return ctx._parentDbn + idx + 1;
     }
     getVarAccessDbn(sym) {
-        const declDbn = this.getVarDeclDbn(sym);
-        return this.dbn - declDbn;
+        // Resolve the de Bruijn index LEXICALLY, against this access's own
+        // scope chain — i.e. the number of binders between the access and the
+        // NEAREST (innermost) enclosing binder of `sym`.
+        //
+        // The previous implementation looked `sym` up in a single tree-wide
+        // `ctxMap` (last writer wins). That is incorrect whenever the same
+        // binder symbol appears in sibling scopes — which happens routinely
+        // because cloned IR reuses its binder symbols (e.g. the shared
+        // `const { tx } = context` destructuring duplicated across a
+        // contract's purpose-match cases). An access in one branch would then
+        // resolve against another branch's binder, yielding a wrong and
+        // sometimes NEGATIVE index ("invalid deBruijn index").
+        let offset = 0;
+        let ctx = this;
+        while (ctx) {
+            const vars = ctx._variables;
+            for (let i = vars.length - 1; i >= 0; i--) {
+                if (vars[i] === sym)
+                    return offset + (vars.length - 1 - i);
+            }
+            offset += vars.length;
+            ctx = ctx.parent;
+        }
+        throw new Error("Variable not found in scope chain: " + String(sym.description));
     }
     toJson() {
         let obj = {};

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -3,6 +3,7 @@ import { IRNative } from "../../../IRNodes/IRNative/index.js";
 import { IRTerm } from "../../../IRTerm.js";
 export declare const hoisted_id: IRHoisted;
 export declare const hoisted_not: IRHoisted;
+export declare const hoisted_equalBoolean: IRHoisted;
 export declare const hoisted_incr: IRHoisted;
 export declare const hoisted_decr: IRHoisted;
 export declare const hoisted_isZero: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -28,6 +28,15 @@ export const hoisted_not = new IRHoisted((() => {
     return new IRFunc([someBool], _ir_apps(IRNative.strictIfThenElse, new IRVar(someBool), IRConst.bool(false), IRConst.bool(true)));
 })());
 hoisted_not.hash;
+// boolean equality: `a == b`  ≡  `if a then b else (not b)`
+export const hoisted_equalBoolean = new IRHoisted((() => {
+    const a = Symbol("a");
+    const b = Symbol("b");
+    return new IRFunc([a, b], _ir_apps(IRNative.strictIfThenElse, new IRVar(a), new IRVar(b), 
+    // not b
+    _ir_apps(IRNative.strictIfThenElse, new IRVar(b), IRConst.bool(false), IRConst.bool(true))));
+})());
+hoisted_equalBoolean.hash;
 export const hoisted_incr = new IRHoisted(new IRApp(IRNative.addInteger, IRConst.int(1)));
 hoisted_incr.hash;
 export const hoisted_decr = new IRHoisted(new IRApp(IRNative.addInteger, IRConst.int(-1)));
@@ -324,7 +333,7 @@ export function nativeToIR(native) {
         case IRNativeTag._increment: return hoisted_addOne.clone();
         case IRNativeTag._decrement: return hoisted_subOne.clone();
         // case IRNativeTag._bytesToIntBE: ;
-        // case IRNativeTag._equalBoolean: ;
+        case IRNativeTag._equalBoolean: return hoisted_equalBoolean.clone();
         // case IRNativeTag._equalPairData: ;
         case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         case IRNativeTag._negateInt: return hoisted_negateInteger.clone();

package/dist/ast/Source/Source.js

@@ -52,8 +52,14 @@ export class Source {
     lineColumn = 1;
     /** Determines the line number at the specified position. Starts at `1`. */
     lineAt(pos) {
-        if (pos < 0 || pos >= 0x7fffffff)
-            throw new Error("pos out of range");
+        // Synthetic / internal nodes carry mock ranges (`SourceRange.mock` uses
+        // -1) and some positions can point past the end of the text. Clamp
+        // instead of throwing, otherwise printing a single diagnostic on such a
+        // node crashes the whole diagnostic pass and hides every later error.
+        if (pos < 0)
+            pos = 0;
+        if (pos >= 0x7fffffff)
+            pos = Math.max(0, this.text.length);
         let lineCache = this.lineCache;
         if (!lineCache) {
             this.lineCache = lineCache = [0];

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanEqualExpr.js

@@ -2,6 +2,8 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 // only aviable for ints and bytes
@@ -11,7 +13,8 @@ export function _compileGreaterThanEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    if (!canAssignTo(left.type, int_t)
+    if (!(getUnaliased(left.type) instanceof TirValueT)
+        && !canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
     let leftType = normalizeEnumToInt(left.type, int_t);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanExpr.js

@@ -2,6 +2,8 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileGreaterThanExpr(ctx, expr, typeHint) {
@@ -10,7 +12,8 @@ export function _compileGreaterThanExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    if (!canAssignTo(left.type, int_t)
+    if (!(getUnaliased(left.type) instanceof TirValueT)
+        && !canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
     let leftType = normalizeEnumToInt(left.type, int_t);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanEqualExpr.js

@@ -2,6 +2,8 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { int_t, bytes_t } from "../../../../tir/program/stdScope/stdScope.js";
 import { _compileExpr } from "../_compileExpr.js";
@@ -9,7 +11,8 @@ export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    if (!canAssignTo(left.type, int_t)
+    if (!(getUnaliased(left.type) instanceof TirValueT)
+        && !canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
     let leftType = normalizeEnumToInt(left.type, int_t);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.js

@@ -2,6 +2,8 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanExpr(ctx, expr, typeHint) {
@@ -10,7 +12,8 @@ export function _compileLessThanExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    if (!canAssignTo(left.type, int_t)
+    if (!(getUnaliased(left.type) instanceof TirValueT)
+        && !canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
     let leftType = normalizeEnumToInt(left.type, int_t);

package/dist/compiler/TirCompiler/expressify/determineReassignedVariablesAndReturn.js

@@ -20,7 +20,11 @@ import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
 import { TirSoPStructType, TirStructConstr, TirStructField } from "../../tir/types/TirStructType.js";
 import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
 export function determineReassignedVariablesAndReturn(stmt) {
-    const originalStmtDeps = stmt.deps();
+    // `keepSortedStrArrInplace` (used below) requires BOTH inputs sorted;
+    // `stmt.deps()` is NOT sorted, so sort a copy here. Without this, reassigned
+    // variables get spuriously dropped from the threaded loop/branch state —
+    // e.g. a `for` loop reassigning two accumulators would freeze all but one.
+    const originalStmtDeps = stmt.deps().slice().sort();
     const stack = [stmt];
     const reassignedSet = new Set();
     let returns = false;
@@ -78,7 +82,11 @@ export function determineReassignedVariablesAndReturn(stmt) {
     };
 }
 export function determineReassignedVariablesAndFlowInfos(stmt) {
-    const originalStmtDeps = stmt.deps();
+    // `keepSortedStrArrInplace` (used below) requires BOTH inputs sorted;
+    // `stmt.deps()` is NOT sorted, so sort a copy here. Without this, reassigned
+    // variables get spuriously dropped from the threaded loop/branch state —
+    // e.g. a `for` loop reassigning two accumulators would freeze all but one.
+    const originalStmtDeps = stmt.deps().slice().sort();
     const stack = [stmt];
     const reassignedSet = new Set();
     let returns = false;

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.js

@@ -12,6 +12,31 @@ import { IRConst } from "../../../../IR/IRNodes/IRConst.js";
 import { compileIRToUPLC } from "../../../../IR/toUPLC/compileIRToUPLC.js";
 import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
 import { _ir_lazyIfThenElse } from "../../../../IR/tree_utils/_ir_lazyIfThenElse.js";
+import { IRFunc } from "../../../../IR/IRNodes/IRFunc.js";
+import { IRVar } from "../../../../IR/IRNodes/IRVar.js";
+/**
+ * Lowering for Value relational operators, in terms of the `valueContains`
+ * builtin (`valueContains(x, y)` ⟺ `x ≥ y`, componentwise):
+ *
+ *   a <= b   →  valueContains(b, a)
+ *   a >= b   →  valueContains(a, b)
+ *   a <  b   →  valueContains(a, b) ? false : valueContains(b, a)
+ *   a >  b   →  valueContains(b, a) ? false : valueContains(a, b)
+ *
+ * `<` / `>` reference each operand twice, so they are bound once via a lambda
+ * to avoid re-evaluating the operand subterms.
+ */
+function _ir_valueContains(geIR, leIR) {
+    // valueContains(ge, le) ⟺ ge ≥ le
+    return _ir_apps(IRNative.valueContains, geIR, leIR);
+}
+/** strict Value `lo < hi` */
+function _ir_valueStrictLess(loIR, hiIR) {
+    const lo = Symbol("vlt_lo");
+    const hi = Symbol("vlt_hi");
+    // (λ lo hi. valueContains(lo, hi) ? false : valueContains(hi, lo)) loIR hiIR
+    return _ir_apps(new IRFunc([lo, hi], _ir_lazyIfThenElse(_ir_valueContains(new IRVar(lo), new IRVar(hi)), IRConst.bool(false), _ir_valueContains(new IRVar(hi), new IRVar(lo)))), loIR, hiIR);
+}
 export function isTirBinaryExpr(thing) {
     return isObject(thing) && (thing instanceof TirExponentiationExpr // int
         || thing instanceof TirLessThanExpr // bool
@@ -89,6 +114,9 @@ export class TirLessThanExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
+        // Value: a < b  →  valueContains(a,b) ? false : valueContains(b,a)
+        if (type instanceof TirValueT)
+            return _ir_valueStrictLess(this.left.toIR(ctx), this.right.toIR(ctx));
         const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanInteger :
             type instanceof TirBytesT ? IRNative.lessThanByteString :
                 undefined);
@@ -126,6 +154,9 @@ export class TirGreaterThanExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
+        // Value: a > b  ≡  b < a
+        if (type instanceof TirValueT)
+            return _ir_valueStrictLess(this.right.toIR(ctx), this.left.toIR(ctx));
         const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanInteger :
             type instanceof TirBytesT ? IRNative.lessThanByteString :
                 undefined);
@@ -165,6 +196,9 @@ export class TirLessThanEqualExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
+        // Value: a <= b  →  valueContains(b, a)   (b ≥ a)
+        if (type instanceof TirValueT)
+            return _ir_valueContains(this.right.toIR(ctx), this.left.toIR(ctx));
         const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanEqualInteger :
             type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
                 undefined);
@@ -202,6 +236,9 @@ export class TirGreaterThanEqualExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
+        // Value: a >= b  →  valueContains(a, b)   (a ≥ b)
+        if (type instanceof TirValueT)
+            return _ir_valueContains(this.left.toIR(ctx), this.right.toIR(ctx));
         const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanEqualInteger :
             type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
                 undefined);

package/dist/compiler/tir/program/stdScope/populateStdNamespace.js

@@ -189,6 +189,8 @@ export function populateStdNamespace(program) {
     defineBuiltin(blsNsScope, "g1HashToGroup", IRNativeTag.bls12_381_G1_hashToGroup, new TirFuncT([bytes_t, bytes_t], g1_t), blsNs);
     defineBuiltin(blsNsScope, "g1Compress", IRNativeTag.bls12_381_G1_compress, new TirFuncT([g1_t], bytes_t), blsNs);
     defineBuiltin(blsNsScope, "g1Uncompress", IRNativeTag.bls12_381_G1_uncompress, new TirFuncT([bytes_t], g1_t), blsNs);
+    // CIP-0381 multi-scalar multiplication: Σ scalars[i] · points[i]
+    defineBuiltin(blsNsScope, "g1MultiScalarMul", IRNativeTag.bls12_381_G1_multiScalarMul, new TirFuncT([new TirListT(int_t), new TirListT(g1_t)], g1_t), blsNs);
     defineBuiltin(blsNsScope, "g2Add", IRNativeTag.bls12_381_G2_add, new TirFuncT([g2_t, g2_t], g2_t), blsNs);
     defineBuiltin(blsNsScope, "g2Neg", IRNativeTag.bls12_381_G2_neg, new TirFuncT([g2_t], g2_t), blsNs);
     defineBuiltin(blsNsScope, "g2ScalarMul", IRNativeTag.bls12_381_G2_scalarMul, new TirFuncT([int_t, g2_t], g2_t), blsNs);
@@ -196,6 +198,7 @@ export function populateStdNamespace(program) {
     defineBuiltin(blsNsScope, "g2HashToGroup", IRNativeTag.bls12_381_G2_hashToGroup, new TirFuncT([bytes_t, bytes_t], g2_t), blsNs);
     defineBuiltin(blsNsScope, "g2Compress", IRNativeTag.bls12_381_G2_compress, new TirFuncT([g2_t], bytes_t), blsNs);
     defineBuiltin(blsNsScope, "g2Uncompress", IRNativeTag.bls12_381_G2_uncompress, new TirFuncT([bytes_t], g2_t), blsNs);
+    defineBuiltin(blsNsScope, "g2MultiScalarMul", IRNativeTag.bls12_381_G2_multiScalarMul, new TirFuncT([new TirListT(int_t), new TirListT(g2_t)], g2_t), blsNs);
     defineBuiltin(blsNsScope, "millerLoop", IRNativeTag.bls12_381_millerLoop, new TirFuncT([g1_t, g2_t], ml_t), blsNs);
     defineBuiltin(blsNsScope, "mulMlResult", IRNativeTag.bls12_381_mulMlResult, new TirFuncT([ml_t, ml_t], ml_t), blsNs);
     defineBuiltin(blsNsScope, "finalVerify", IRNativeTag.bls12_381_finalVerify, new TirFuncT([ml_t, ml_t], bool_t), blsNs);

package/dist/compiler/tir/program/stdScope/stdScope.js

@@ -47,6 +47,8 @@ export function populateStdScope(program) {
     }
     _defineStdUnambigous(void_t);
     _defineStdUnambigous(bool_t);
+    // `bool` is a common spelling; accept it as an alias for `boolean`.
+    stdScope.defineUnambigousType("bool", bool_t.toTirTypeKey(), true, new Map());
     _defineStdUnambigous(int_t);
     _defineStdUnambigous(bytes_t);
     _defineStdUnambigous(string_t);

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.3.2";
+export declare const COMPILER_VERSION = "0.3.4";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.3.2";
+export const COMPILER_VERSION = "0.3.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",