@harmoniclabs/pebble 0.1.3-dev0 → 0.1.3-dev2

package/dist/IR/IRNodes/IRConst.js

@@ -1,4 +1,3 @@
-import { Pair } from "@harmoniclabs/pair";
 import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
 import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
@@ -11,7 +10,7 @@ import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType } from "../../compiler/tir/types/TirStructType.js";
 import { getListTypeArg } from "../../compiler/tir/types/utils/getListTypeArg.js";
 import { TirTypeParam } from "../../compiler/tir/types/TirTypeParam.js";
-import { constT, UPLCConst } from "@harmoniclabs/uplc";
+import { constT, isPair, UPLCConst } from "@harmoniclabs/uplc";
 import { TirPairDataT, TirUnConstrDataResultT } from "../../compiler/tir/types/TirNativeType/index.js";
 import { TirBoolT } from "../../compiler/tir/types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../../compiler/tir/types/TirNativeType/native/bytes.js";
@@ -25,10 +24,9 @@ import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Option
 import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string.js";
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
-import { ByteString } from "@harmoniclabs/bytestring";
 import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 export function isIRConstPair(value) {
-    return (value instanceof Pair &&
+    return (isPair(value) &&
         isIRConstValue(value.fst) &&
         isIRConstValue(value.snd));
 }
@@ -65,7 +63,7 @@ export class IRConst {
         const type = getUnaliased(this.type);
         if (type instanceof TirBytesT && this.value instanceof Uint8Array) {
             // make a copy to prevent external mutation
-            return new UPLCConst(tirTypeToUplcType(type), new ByteString(this.value));
+            return new UPLCConst(tirTypeToUplcType(type), this.value);
         }
         return new UPLCConst(tirTypeToUplcType(type), this.value);
     }
@@ -215,7 +213,7 @@ function serializeIRConstValue(value, type) {
     if (type instanceof TirDataT
         || type instanceof TirDataOptT
         || type instanceof TirDataStructType)
-        return dataToCbor(value).toBuffer();
+        return dataToCbor(value);
     if (type instanceof TirFuncT
         || type instanceof TirSopOptT
         || type instanceof TirSoPStructType

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -20,6 +20,7 @@ import { _debug_assertClosedIR } from "../utils/index.js";
 import { ToUplcCtx } from "./ctx/ToUplcCtx.js";
 import { removeUnusedVarsAndReturnRoot } from "./subRoutines/removeUnusuedVarsAndReturnRoot/removeUnusuedVarsAndReturnRoot.js";
 import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { ensureProperlyForcedBuiltinsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.js";
 export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // most of the time we are just compiling small
     // pre-execuded terms (hence constants)
@@ -144,6 +145,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // }
     term = removeUnusedVarsAndReturnRoot(term);
     term = performUplcOptimizationsAndReturnRoot(term, options);
+    term = ensureProperlyForcedBuiltinsAndReturnRoot(term);
     if (options.addMarker &&
         options.targetUplcVersion.major >= 1 &&
         options.targetUplcVersion.minor >= 1 &&

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../../IRTerm.js";
+export declare function ensureProperlyForcedBuiltinsAndReturnRoot(root: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.js

@@ -0,0 +1,163 @@
+import { IRConstr, IRNative } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { IRForced } from "../../../IRNodes/IRForced.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { getUnboundedVars } from "../handleLetted/groupByScope.js";
+import { getNRequiredForces } from "@harmoniclabs/uplc";
+export function ensureProperlyForcedBuiltinsAndReturnRoot(root) {
+    // const opts = options.uplcOptimizations;
+    // if( isDebugUplcOptimizations( opts ) ) return root;
+    // const {
+    //     groupApplications,
+    //     inlineSingleUse: shouldInlineSingleUse,
+    //     simplifyWrappedPartialFuncApps,
+    //     removeForceDelay
+    // } = opts;
+    const stack = [root];
+    let t = root;
+    while (t = stack.pop()) {
+        if (t instanceof IRNative) {
+            const expectedForces = getNRequiredForces(t.tag);
+            if (expectedForces <= 0)
+                continue;
+            let newNode = t;
+            let nDirectForces = 0;
+            // save the original parent before walking up through existing forces
+            // and before creating new IRForced wrappers (whose constructors
+            // overwrite the child's parent pointer)
+            const originalParent = t.parent;
+            while (t.parent instanceof IRForced) {
+                nDirectForces++;
+                t = t.parent;
+            }
+            if (nDirectForces === expectedForces)
+                continue;
+            // when nDirectForces > 0, t has walked up to the topmost IRForced;
+            // save its parent before wrapping overwrites parent pointers
+            const replaceInParent = nDirectForces > 0 ? t.parent : originalParent;
+            for (let i = 0; i < expectedForces - nDirectForces; i++) {
+                newNode = new IRForced(newNode);
+            }
+            if (replaceInParent)
+                _modifyChildFromTo(replaceInParent, t, newNode);
+            else
+                root = newNode;
+            continue;
+        }
+        if (t instanceof IRRecursive ||
+            t instanceof IRHoisted ||
+            t instanceof IRLetted ||
+            t instanceof IRSelfCall)
+            throw new Error("Unexpected term while performing uplc optimizations");
+        stack.push(...t.children());
+    }
+    return root;
+}
+function isIdLike(term) {
+    return (term instanceof IRFunc &&
+        term.params.length === 1 &&
+        term.body instanceof IRVar &&
+        term.body.name === term.params[0]);
+}
+/**
+ *
+ * @returns either an object containing the new root, sorted args and next body
+ *          or undefined if grouping wasnt possible (root is the same)
+ */
+function groupIndependentApplications(root) {
+    const parent = root.parent;
+    let applicaitonTerms = getApplicationTerms(root);
+    if (!applicaitonTerms)
+        return undefined;
+    let { func, args } = applicaitonTerms;
+    if (!(func instanceof IRFunc))
+        return undefined;
+    const params = func.params.slice();
+    while (true) {
+        applicaitonTerms = getApplicationTerms(func.body);
+        if (!applicaitonTerms)
+            break;
+        if (!(applicaitonTerms.func instanceof IRFunc))
+            break;
+        func = applicaitonTerms.func;
+        params.push(...func.params);
+        args.push(...applicaitonTerms.args);
+        if (params.length !== args.length)
+            break;
+    }
+    const len = Math.min(params.length, args.length);
+    const finalParams = params.slice(len);
+    const finalArgs = args.slice(len);
+    params.length = len;
+    args.length = len;
+    const paramToArg = {};
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        paramToArg[p] = args[i];
+    }
+    const globalUnbound = getUnboundedVars(root);
+    const groups = [[]];
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        const arg = args[i];
+        const unbound = getUnboundedVars(arg, globalUnbound);
+        let highestIdx = -1;
+        for (let j = groups.length - 1; j >= 0; j--) {
+            const group = groups[j];
+            if (group.some(sym => unbound.has(sym))) {
+                highestIdx = j;
+                break;
+            }
+        }
+        if (highestIdx === groups.length - 1) {
+            groups.push([p]);
+            continue;
+        }
+        groups[highestIdx + 1].push(p);
+    }
+    groups[groups.length - 1].push(...finalParams);
+    const sortedArgs = new Array(len);
+    const soretedParams = groups.flat();
+    for (let i = 0; i < len; i++) {
+        const p = soretedParams[i];
+        sortedArgs[i] = paramToArg[p];
+    }
+    let nextBody = func.body;
+    if (finalArgs.length > 0) {
+        if (finalArgs.length === 1) {
+            nextBody = new IRApp(nextBody, finalArgs[0]);
+        }
+        else {
+            nextBody = new IRCase(new IRConstr(0, finalArgs), [nextBody]);
+        }
+    }
+    let newTerm = nextBody;
+    for (let i = groups.length - 1; i >= 0; i--) {
+        const group = groups[i];
+        if (group.length === 1) {
+            newTerm = new IRApp(new IRFunc(group, newTerm), paramToArg[group[0]]);
+        }
+        else if (group.length <= 0)
+            continue;
+        else {
+            newTerm = new IRCase(new IRConstr(0, group.map(p => paramToArg[p])), [new IRFunc(group, newTerm)]);
+        }
+    }
+    if (parent)
+        _modifyChildFromTo(parent, root, newTerm);
+    else
+        root = newTerm;
+    return {
+        newRoot: !parent ? root : undefined,
+        args: sortedArgs,
+        nextBody
+    };
+}

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/performUplcOptimizationsAndReturnRoot.js

@@ -89,6 +89,10 @@ function groupIndependentApplications(root) {
     if (!(func instanceof IRFunc))
         return undefined;
     const params = func.params.slice();
+    // Separate excess outer args: getApplicationTerms may return more args
+    // than func.params (e.g. `(λp. body)(arg1)(arg2)` → 2 args, 1 param).
+    // Excess args are trailing applications applied after all param bindings.
+    const trailingArgs = args.splice(params.length);
     while (true) {
         applicaitonTerms = getApplicationTerms(func.body);
         if (!applicaitonTerms)
@@ -96,14 +100,20 @@ function groupIndependentApplications(root) {
         if (!(applicaitonTerms.func instanceof IRFunc))
             break;
         func = applicaitonTerms.func;
+        const nNewParams = func.params.length;
+        const innerArgs = applicaitonTerms.args;
         params.push(...func.params);
-        args.push(...applicaitonTerms.args);
+        args.push(...innerArgs.slice(0, nNewParams));
+        // Inner excess args are applied before outer excess args
+        if (innerArgs.length > nNewParams) {
+            trailingArgs.unshift(...innerArgs.slice(nNewParams));
+        }
         if (params.length !== args.length)
             break;
     }
     const len = Math.min(params.length, args.length);
     const finalParams = params.slice(len);
-    const finalArgs = args.slice(len);
+    const finalArgs = [...args.slice(len), ...trailingArgs];
     params.length = len;
     args.length = len;
     const paramToArg = {};

package/dist/IR/tree_utils/intToUtf8Bytes.d.ts

@@ -0,0 +1,8 @@
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+/**
+ * Hoisted IR term: `int -> bytes`
+ *
+ * Converts an integer to its decimal UTF-8 byte representation.
+ * Handles negative numbers by prepending '-' (0x2d).
+ */
+export declare const hoisted_intToUtf8Bytes: IRHoisted;

package/dist/IR/tree_utils/intToUtf8Bytes.js

@@ -0,0 +1,49 @@
+import { IRApp, _ir_apps } from "../IRNodes/IRApp.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+import { IRFunc } from "../IRNodes/IRFunc.js";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRNative } from "../IRNodes/IRNative/index.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../IRNodes/IRSelfCall.js";
+import { IRVar } from "../IRNodes/IRVar.js";
+import { _ir_lazyIfThenElse } from "./_ir_lazyIfThenElse.js";
+// digitToBytes(n) = consByteString( addInteger(n, 48), #"" )
+// positiveIntToBs = fix \self \n ->
+//   ifThenElse (lessThanInteger n 10)
+//     (consByteString (addInteger n 48) #"")
+//     (appendByteString (self (divideInteger n 10)) (consByteString (addInteger (modInteger n 10) 48) #""))
+// intToUtf8Bytes(n) =
+//   ifThenElse (lessThanEqualInteger 0 n)
+//     (positiveIntToBs n)
+//     (appendByteString (consByteString 45 #"") (positiveIntToBs (subtractInteger 0 n)))
+const self_sym = Symbol("intToUtf8Bytes_self");
+const n_sym = Symbol("intToUtf8Bytes_n");
+const outer_n_sym = Symbol("intToUtf8Bytes_outer_n");
+const emptyBs = IRConst.bytes(new Uint8Array(0));
+function digitToBytes(n) {
+    return _ir_apps(IRNative.consByteString, _ir_apps(IRNative.addInteger, n, IRConst.int(48)), emptyBs.clone());
+}
+const hoisted_positiveIntToBs = new IRHoisted(new IRRecursive(self_sym, new IRFunc([n_sym], _ir_lazyIfThenElse(
+// condition: n < 10
+_ir_apps(IRNative.lessThanInteger, new IRVar(n_sym), IRConst.int(10)), 
+// then: digitToBytes(n)
+digitToBytes(new IRVar(n_sym)), 
+// else: appendByteString( self(n / 10), digitToBytes(n % 10) )
+_ir_apps(IRNative.appendByteString, new IRApp(new IRSelfCall(self_sym), _ir_apps(IRNative.divideInteger, new IRVar(n_sym), IRConst.int(10))), digitToBytes(_ir_apps(IRNative.modInteger, new IRVar(n_sym), IRConst.int(10))))))));
+hoisted_positiveIntToBs.hash;
+/**
+ * Hoisted IR term: `int -> bytes`
+ *
+ * Converts an integer to its decimal UTF-8 byte representation.
+ * Handles negative numbers by prepending '-' (0x2d).
+ */
+export const hoisted_intToUtf8Bytes = new IRHoisted(new IRFunc([outer_n_sym], _ir_lazyIfThenElse(
+// condition: 0 <= n
+_ir_apps(IRNative.lessThanEqualInteger, IRConst.int(0), new IRVar(outer_n_sym)), 
+// then: positiveIntToBs(n)
+_ir_apps(hoisted_positiveIntToBs.clone(), new IRVar(outer_n_sym)), 
+// else: appendByteString( consByteString(45, #""), positiveIntToBs(0 - n) )
+_ir_apps(IRNative.appendByteString, 
+// "-" as bytes
+_ir_apps(IRNative.consByteString, IRConst.int(45), emptyBs.clone()), _ir_apps(hoisted_positiveIntToBs.clone(), _ir_apps(IRNative.subtractInteger, IRConst.int(0), new IRVar(outer_n_sym)))))));
+hoisted_intToUtf8Bytes.hash;

package/dist/ast/nodes/statements/PebbleStmt.d.ts

@@ -24,7 +24,8 @@ import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { InterfaceDecl } from "./declarations/InterfaceDecl.js";
 import { ContractDecl } from "./declarations/ContractDecl.js";
+import { TraceStmt } from "./TraceStmt.js";
 export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt | ContractDecl;
 export declare function isTopLevelStmt(stmt: any): stmt is TopLevelStmt;
-export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | MatchStmt | AssignmentStmt | UsingStmt;
+export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | TraceStmt | MatchStmt | AssignmentStmt | UsingStmt;
 export declare function isBodyStmt(stmt: any): stmt is BodyStmt;

package/dist/ast/nodes/statements/PebbleStmt.js

@@ -26,6 +26,7 @@ import { UsingStmt } from "./UsingStmt.js";
 import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { ContractDecl } from "./declarations/ContractDecl.js";
+import { TraceStmt } from "./TraceStmt.js";
 export function isTopLevelStmt(stmt) {
     return (stmt instanceof EmptyStmt
         || stmt instanceof VarStmt
@@ -55,6 +56,7 @@ export function isBodyStmt(stmt) {
         || stmt instanceof EmptyStmt
         || stmt instanceof FailStmt
         || stmt instanceof AssertStmt
+        || stmt instanceof TraceStmt
         || stmt instanceof MatchStmt
         || isAssignmentStmt(stmt)
         // || stmt instanceof ExprStmt

package/dist/ast/nodes/statements/TraceStmt.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+export declare class TraceStmt implements HasSourceRange {
+    /** expression to trace (must be string) */
+    expr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(
+    /** expression to trace (must be string) */
+    expr: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/TraceStmt.js

@@ -0,0 +1,10 @@
+export class TraceStmt {
+    expr;
+    range;
+    constructor(
+    /** expression to trace (must be string) */
+    expr, range) {
+        this.expr = expr;
+        this.range = range;
+    }
+}

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -43,6 +43,17 @@ export declare class AstCompiler extends DiagnosticEmitter {
     constructor(cfg: CompilerOptions, io?: CompilerIoApi, diagnostics?: DiagnosticMessage[]);
     private _isExporting;
     export(funcName: string, modulePath?: string): Promise<TypedProgram>;
+    /**
+     * Parses the entry file, wraps all top-level statements
+     * (except functions, contracts, type declarations, imports, and exports)
+     * into a synthetic function, then compiles via export.
+     *
+     * The wrapping is done at the source text level (before parsing)
+     * so that statements which are not parseable at the top level
+     * (e.g. for loops, assignments, trace calls) become valid
+     * inside a function body.
+     */
+    run(): Promise<TypedProgram>;
     /**
      * compiles the entry file specified in the config
      *

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -104,6 +104,38 @@ export class AstCompiler extends DiagnosticEmitter {
         this.program.contractTirFuncName = funcName;
         return await this.compile();
     }
+    /**
+     * Parses the entry file, wraps all top-level statements
+     * (except functions, contracts, type declarations, imports, and exports)
+     * into a synthetic function, then compiles via export.
+     *
+     * The wrapping is done at the source text level (before parsing)
+     * so that statements which are not parseable at the top level
+     * (e.g. for loops, assignments, trace calls) become valid
+     * inside a function body.
+     */
+    async run() {
+        const RUN_FUNC_NAME = "__pebble_run__";
+        this._isExporting = true;
+        this.program.contractTirFuncName = RUN_FUNC_NAME;
+        const filePath = this.cfg.entry;
+        if (!filePath) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
+            throw new Error("entry file not found");
+        }
+        if (!this.io.exsistSync(filePath))
+            throw new Error("AstCompiler.run: entry file does not exist: " + filePath);
+        const src = await this.getAbsoulteProjPathSource(filePath);
+        if (!src)
+            throw new Error("AstCompiler.run: could not read source: " + filePath);
+        // 1) Rewrite the source text: wrap non-declaration statements in a function
+        src.text = _wrapSourceTextForRun(src.text, RUN_FUNC_NAME);
+        // update range to match the new text length
+        src.range.end = src.text.length;
+        // 2) Use the normal compilation pipeline (parse + semantic analysis)
+        //    which now sees the entry source as having a top-level function
+        return await this.compile();
+    }
     /**
      * compiles the entry file specified in the config
      *
@@ -676,3 +708,156 @@ function isImportStmtLike(stmt) {
         || stmt instanceof ImportStarStmt
         || stmt instanceof ExportStarStmt);
 }
+/** Keywords that start a top-level declaration (kept outside the run wrapper). */
+const _declKeywords = new Set([
+    "import",
+    "export",
+    "function",
+    "struct",
+    "enum",
+    "type",
+    "interface",
+    "contract",
+    "data",
+    "runtime",
+]);
+/**
+ * Splits source text into declaration blocks and body blocks
+ * using a simple character scanner, then wraps body blocks
+ * in a `function <funcName>(): void { ... }`.
+ *
+ * Declaration keywords (import, export, function, struct, enum, type, interface,
+ * contract, data, runtime) are recognized at the start of each top-level statement
+ * and kept outside the wrapper. Everything else goes inside the wrapper function.
+ */
+function _wrapSourceTextForRun(text, funcName) {
+    const len = text.length;
+    const ranges = [];
+    let pos = 0;
+    while (pos < len) {
+        // skip whitespace
+        while (pos < len && _isWhitespace(text.charCodeAt(pos)))
+            pos++;
+        if (pos >= len)
+            break;
+        const stmtStart = pos;
+        // read the first word to determine if this is a declaration
+        const word = _readWord(text, pos);
+        const isDecl = _declKeywords.has(word);
+        // find the end of this statement:
+        // track brace/paren depth, respect strings and comments
+        let braceDepth = 0;
+        let parenDepth = 0;
+        let ended = false;
+        while (pos < len && !ended) {
+            const ch = text.charCodeAt(pos);
+            // single-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F /* / */) {
+                pos += 2;
+                while (pos < len && text.charCodeAt(pos) !== 0x0A /* \n */)
+                    pos++;
+                continue;
+            }
+            // multi-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2A /* * */) {
+                pos += 2;
+                while (pos < len && !(text.charCodeAt(pos) === 0x2A && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F))
+                    pos++;
+                pos += 2; // skip */
+                continue;
+            }
+            // string literals
+            if (ch === 0x22 /* " */ || ch === 0x27 /* ' */ || ch === 0x60 /* ` */) {
+                pos++;
+                while (pos < len) {
+                    const sc = text.charCodeAt(pos);
+                    if (sc === 0x5C /* \ */) {
+                        pos += 2;
+                        continue;
+                    } // escaped char
+                    if (sc === ch) {
+                        pos++;
+                        break;
+                    }
+                    pos++;
+                }
+                continue;
+            }
+            if (ch === 0x28 /* ( */) {
+                parenDepth++;
+                pos++;
+            }
+            else if (ch === 0x29 /* ) */) {
+                parenDepth--;
+                pos++;
+            }
+            else if (ch === 0x7B /* { */) {
+                braceDepth++;
+                pos++;
+            }
+            else if (ch === 0x7D /* } */) {
+                braceDepth--;
+                pos++;
+                if (braceDepth <= 0 && parenDepth <= 0) {
+                    // consume optional trailing semicolon
+                    let p2 = pos;
+                    while (p2 < len && _isWhitespace(text.charCodeAt(p2)))
+                        p2++;
+                    if (p2 < len && text.charCodeAt(p2) === 0x3B /* ; */)
+                        pos = p2 + 1;
+                    ended = true;
+                }
+            }
+            else if (ch === 0x3B /* ; */ && braceDepth === 0 && parenDepth === 0) {
+                pos++;
+                ended = true;
+            }
+            else {
+                pos++;
+            }
+        }
+        const stmtEnd = pos;
+        // skip empty ranges
+        if (stmtEnd > stmtStart) {
+            ranges.push({ start: stmtStart, end: stmtEnd, isDecl });
+        }
+    }
+    // If there are no body ranges, nothing to wrap
+    if (ranges.every(r => r.isDecl)) {
+        return text;
+    }
+    // Build the new source text
+    const declarations = [];
+    const bodyParts = [];
+    for (const r of ranges) {
+        const slice = text.substring(r.start, r.end);
+        if (r.isDecl)
+            declarations.push(slice);
+        else
+            bodyParts.push(slice);
+    }
+    return (declarations.join("\n") +
+        (declarations.length > 0 ? "\n" : "") +
+        "function " + funcName + "(): void {\n" +
+        bodyParts.join("\n") + "\n" +
+        "}\n");
+}
+function _isWhitespace(ch) {
+    return ch === 0x20 || ch === 0x09 || ch === 0x0A || ch === 0x0D;
+}
+function _readWord(text, pos) {
+    const start = pos;
+    const len = text.length;
+    while (pos < len) {
+        const ch = text.charCodeAt(pos);
+        if ((ch >= 0x61 && ch <= 0x7A) || // a-z
+            (ch >= 0x41 && ch <= 0x5A) || // A-Z
+            (ch >= 0x30 && ch <= 0x39) || // 0-9
+            ch === 0x5F // _
+        )
+            pos++;
+        else
+            break;
+    }
+    return text.substring(start, pos);
+}

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -40,6 +40,7 @@ import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
 import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
 import { MatchStmtCase, MatchStmt, MatchStmtElseCase } from "../../../../ast/nodes/statements/MatchStmt.js";
 import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
 import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
 import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
@@ -589,6 +590,13 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
             stmt.body = new BlockStmt(nextBodyStmts, stmt.body.range);
             continue;
         }
+        if (stmt instanceof TraceStmt) {
+            const newExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.expr, paramsInternalNamesMap, renamedVariables);
+            if (!newExpr)
+                return undefined;
+            stmt.expr = newExpr;
+            continue;
+        }
         const tsEnsureExhaustiveCheck = stmt;
         console.error(stmt);
         throw new Error("unreachable::_getMatchedRedeemerBlockStatements::stmt::");

package/dist/compiler/AstCompiler/internal/statements/_compileStatement.js

@@ -6,6 +6,7 @@ import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
 import { isVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
 import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
 import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
 import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
 import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
 import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
@@ -20,6 +21,7 @@ import { _compileBlockStmt } from "./_compileBlockStmt.js";
 import { _compileBreakStmt } from "./_compileBreakStmt.js";
 import { _compileContinueStmt } from "./_compileContinueStmt.js";
 import { _compileFailStmt } from "./_compileFailStmt.js";
+import { _compileTraceStmt } from "./_compileTraceStmt.js";
 import { _compileForOfStmt } from "./_compileForOfStmt.js";
 import { _compileForStmt } from "./_compileForStmt.js";
 import { _compileIfStmt } from "./_compileIfStmt.js";
@@ -62,6 +64,8 @@ export function _compileStatement(ctx, stmt) {
         return _compileFailStmt(ctx, stmt);
     if (stmt instanceof AssertStmt)
         return _compileAssertStmt(ctx, stmt);
+    if (stmt instanceof TraceStmt)
+        return _compileTraceStmt(ctx, stmt);
     // if( stmt instanceof TestStmt ) return _compileTestStmt( ctx, stmt );
     if (stmt instanceof MatchStmt)
         return _compileMatchStmt(ctx, stmt);

package/dist/compiler/AstCompiler/internal/statements/_compileTraceStmt.d.ts

@@ -0,0 +1,4 @@
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
+import { TirTraceStmt } from "../../../tir/statements/TirTraceStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileTraceStmt(ctx: AstCompilationCtx, stmt: TraceStmt): [TirTraceStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileTraceStmt.js

@@ -0,0 +1,15 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirTraceStmt } from "../../../tir/statements/TirTraceStmt.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileTraceStmt(ctx, stmt) {
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const int_t = ctx.program.stdTypes.int;
+    let expr = _compileExpr(ctx, stmt.expr, undefined);
+    if (!expr)
+        return undefined;
+    if (!canAssignTo(expr.type, bytes_t) &&
+        !canAssignTo(expr.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.expr.range, expr.type.toString(), "bytes | int");
+    return [new TirTraceStmt(expr, stmt.range)];
+}