@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -23,7 +23,8 @@ import { UsingStmt } from "./UsingStmt.js";
 import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { InterfaceDecl } from "./declarations/InterfaceDecl.js";
-export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt;
+import { ContractDecl } from "./declarations/ContractDecl.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 declare function isBodyStmt(stmt: any): stmt is BodyStmt;

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

@@ -25,6 +25,7 @@ import { DecrStmt } from "./DecrStmt.js";
 import { UsingStmt } from "./UsingStmt.js";
 import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
+import { ContractDecl } from "./declarations/ContractDecl.js";
 export function isTopLevelStmt(stmt) {
     return (stmt instanceof EmptyStmt
         || stmt instanceof VarStmt
@@ -37,7 +38,8 @@ export function isTopLevelStmt(stmt) {
         || stmt instanceof ImportStmt
         || stmt instanceof ImportStarStmt
         || stmt instanceof TypeImplementsStmt
-        || stmt instanceof UsingStmt);
+        || stmt instanceof UsingStmt
+        || stmt instanceof ContractDecl);
 }
 export function isBodyStmt(stmt) {
     return (stmt instanceof IfStmt

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

@@ -2,7 +2,7 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 export declare class ReturnStmt implements HasSourceRange {
-    readonly value: PebbleExpr | undefined;
+    value: PebbleExpr | undefined;
     readonly range: SourceRange;
     constructor(value: PebbleExpr | undefined, range: SourceRange);
 }

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

@@ -1,10 +1,12 @@
 import { SourceRange } from "../../Source/SourceRange.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
+import { BlockStmt } from "./BlockStmt.js";
 import { BodyStmt } from "./PebbleStmt.js";
 export declare class WhileStmt implements HasSourceRange {
-    readonly condition: PebbleExpr;
-    readonly body: BodyStmt;
+    condition: PebbleExpr;
+    body: BodyStmt;
     readonly range: SourceRange;
     constructor(condition: PebbleExpr, body: BodyStmt, range: SourceRange);
+    bodyBlock(): BlockStmt;
 }

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

@@ -1,3 +1,4 @@
+import { BlockStmt } from "./BlockStmt.js";
 export class WhileStmt {
     condition;
     body;
@@ -7,4 +8,9 @@ export class WhileStmt {
         this.body = body;
         this.range = range;
     }
+    bodyBlock() {
+        if (this.body instanceof BlockStmt)
+            return this.body;
+        return new BlockStmt([this.body], this.body.range);
+    }
 }

package/dist/ast/nodes/statements/declarations/ContractDecl.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { FuncDecl } from "./FuncDecl.js";
+import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
+export declare class ContractDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly params: SimpleVarDecl[];
+    readonly spendMethods: FuncDecl[];
+    readonly mintMethods: FuncDecl[];
+    readonly certifyMethods: FuncDecl[];
+    readonly withdrawMethods: FuncDecl[];
+    readonly proposeMethods: FuncDecl[];
+    readonly voteMethods: FuncDecl[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, params: SimpleVarDecl[], spendMethods: FuncDecl[], mintMethods: FuncDecl[], certifyMethods: FuncDecl[], withdrawMethods: FuncDecl[], proposeMethods: FuncDecl[], voteMethods: FuncDecl[], range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/ContractDecl.js

@@ -0,0 +1,22 @@
+export class ContractDecl {
+    name;
+    params;
+    spendMethods;
+    mintMethods;
+    certifyMethods;
+    withdrawMethods;
+    proposeMethods;
+    voteMethods;
+    range;
+    constructor(name, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, range) {
+        this.name = name;
+        this.params = params;
+        this.spendMethods = spendMethods;
+        this.mintMethods = mintMethods;
+        this.certifyMethods = certifyMethods;
+        this.withdrawMethods = withdrawMethods;
+        this.proposeMethods = proposeMethods;
+        this.voteMethods = voteMethods;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.d.ts

@@ -10,7 +10,7 @@ export declare class ArrayLikeDeconstr implements HasSourceRange, HasInitExpr {
     readonly elements: VarDecl[];
     readonly rest: Identifier | undefined;
     type: AstTypeExpr | undefined;
-    readonly initExpr: PebbleExpr | undefined;
+    initExpr: PebbleExpr | undefined;
     flags: CommonFlags;
     readonly range: SourceRange;
     constructor(elements: VarDecl[], rest: Identifier | undefined, type: AstTypeExpr | undefined, // just for the type checker, or func params, usually this is inferred

package/dist/ast/nodes/statements/declarations/VarDecl/HasInit.d.ts

@@ -1,5 +1,5 @@
 import { PebbleExpr } from "../../../expr/PebbleExpr.js";
 export interface HasInitExpr {
-    readonly initExpr: PebbleExpr | undefined;
+    initExpr: PebbleExpr | undefined;
 }
 export declare function hasInitExpr(thing: any): thing is HasInitExpr;

package/dist/ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.d.ts

@@ -12,7 +12,7 @@ export declare class NamedDeconstructVarDecl implements HasSourceRange, ISingleD
     readonly fields: Map<Identifier, VarDecl>;
     readonly rest: Identifier | undefined;
     type: AstTypeExpr | undefined;
-    readonly initExpr: PebbleExpr | undefined;
+    initExpr: PebbleExpr | undefined;
     flags: CommonFlags;
     readonly range: SourceRange;
     constructor(

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.d.ts

@@ -8,10 +8,11 @@ import { HasInitExpr } from "./HasInit.js";
 export declare class SimpleVarDecl implements HasSourceRange, HasInitExpr {
     readonly name: Identifier;
     type: AstTypeExpr | undefined;
-    readonly initExpr: PebbleExpr | undefined;
+    initExpr: PebbleExpr | undefined;
     flags: CommonFlags;
     readonly range: SourceRange;
     constructor(name: Identifier, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);
     isConst(): boolean;
     static onlyIdentifier(identifier: Identifier, flags: CommonFlags): SimpleVarDecl;
+    static onlyNameConst(name: string, range: SourceRange): SimpleVarDecl;
 }

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js

@@ -1,4 +1,5 @@
 import { CommonFlags } from "../../../../../common.js";
+import { Identifier } from "../../../common/Identifier.js";
 export class SimpleVarDecl {
     name;
     type;
@@ -18,4 +19,9 @@ export class SimpleVarDecl {
     static onlyIdentifier(identifier, flags) {
         return new SimpleVarDecl(identifier, undefined, undefined, flags, identifier.range);
     }
+    static onlyNameConst(name, range) {
+        return new SimpleVarDecl(new Identifier(name, range), undefined, // type
+        undefined, // initExpr
+        CommonFlags.Const, range);
+    }
 }

package/dist/ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.d.ts

@@ -16,7 +16,7 @@ export declare class SingleDeconstructVarDecl implements HasSourceRange, ISingle
     readonly fields: Map<Identifier, VarDecl>;
     readonly rest: Identifier | undefined;
     type: AstTypeExpr | undefined;
-    readonly initExpr: PebbleExpr | undefined;
+    initExpr: PebbleExpr | undefined;
     flags: CommonFlags;
     readonly range: SourceRange;
     constructor(fields: Map<Identifier, VarDecl>, rest: Identifier | undefined, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);

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

@@ -1,3 +1,5 @@
+import { StructDecl } from "../../ast/nodes/statements/declarations/StructDecl.js";
+import { TypeAliasDecl } from "../../ast/nodes/statements/declarations/TypeAliasDecl.js";
 import { Source } from "../../ast/Source/Source.js";
 import { DiagnosticEmitter } from "../../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticMessage } from "../../diagnostics/DiagnosticMessage.js";
@@ -45,7 +47,7 @@ export declare class AstCompiler extends DiagnosticEmitter {
      * the result is store in `this.program`
      */
     compile(): Promise<TypedProgram>;
-    compileFile(path: string, isMain?: boolean): Promise<Source | undefined>;
+    compileFile(path: string, isEntryFile?: boolean): Promise<Source | undefined>;
     private readonly _srcDonelogUids;
     /**
      * translates the source AST statements
@@ -54,8 +56,10 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _compileParsedSource;
     private _collectAllTopLevelSignatures;
     private _collectInterfaceImplSigs;
+    private _collectTopLevelConst;
     private _collectTopLevelFuncDeclSig;
     private _collectInterfaceDeclarations;
+    registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl): void;
     private _collectTypeDeclarations;
     private _compileStructDecl;
     private _compileTypeAliasDecl;
@@ -67,7 +71,8 @@ export declare class AstCompiler extends DiagnosticEmitter {
     /**
      * @returns `true` if there were no errors. `false` otherwise.
      */
-    compileAllDeps(_resolveStackNode: ResolveStackNode, isMain?: boolean): Promise<boolean>;
+    compileAllDeps(_resolveStackNode: ResolveStackNode, isEntryFile?: boolean): Promise<boolean>;
     private importPathsFromStmts;
     private _reportCircularDependency;
+    private _contractDeclToFuncDecl;
 }

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -19,10 +19,10 @@ import { _compileDataEncodedConcreteType } from "./internal/types/_compileDataEn
 import { getAbsolutePath, getEnvRelativePath } from "../path/getAbsolutePath.js";
 import { _compileSopEncodedConcreteType } from "./internal/types/_compileSopEncodedConcreteType.js";
 import { InterfaceDecl } from "../../ast/nodes/statements/declarations/InterfaceDecl.js";
-import { AstFuncType } from "../../ast/nodes/types/AstNativeTypeExpr.js";
+import { AstFuncType, AstVoidType } from "../../ast/nodes/types/AstNativeTypeExpr.js";
 import { FuncDecl } from "../../ast/nodes/statements/declarations/FuncDecl.js";
 import { InterfaceMethodImpl, TypeImplementsStmt } from "../../ast/nodes/statements/TypeImplementsStmt.js";
-import { PEBBLE_INTERNAL_IDENTIFIER_PREFIX } from "../internalVar.js";
+import { getUniqueInternalName, PEBBLE_INTERNAL_IDENTIFIER_PREFIX } from "../internalVar.js";
 import { AstNamedTypeExpr } from "../../ast/nodes/types/AstNamedTypeExpr.js";
 import { FuncExpr } from "../../ast/nodes/expr/functions/FuncExpr.js";
 import { CommonFlags } from "../../common.js";
@@ -30,6 +30,11 @@ import { SimpleVarDecl } from "../../ast/nodes/statements/declarations/VarDecl/S
 import { Identifier } from "../../ast/nodes/common/Identifier.js";
 import { ArrowKind } from "../../ast/nodes/expr/functions/ArrowKind.js";
 import { _compileFuncExpr } from "./internal/exprs/_compileFuncExpr.js";
+import { ContractDecl } from "../../ast/nodes/statements/declarations/ContractDecl.js";
+import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContractBody.js";
+import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
+import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
+import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -96,17 +101,22 @@ export class AstCompiler extends DiagnosticEmitter {
         const entrySrc = await this.compileFile(filePath, true);
         if (this.diagnostics.length > 0 || !entrySrc) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
-                this.io.stdout.write(msg.toString() + "\n");
+                /*
+                this.io.stdout.write( msg.toString() + "\n" );
+                /*/
+                console.log(msg);
+                console.log(msg.toString());
+                //*/
             }
             throw new Error("AstCompiler.compile: failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
         const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
         if (this.program.contractTirFuncName === "" || !mainFuncExpr) {
-            this.error(DiagnosticCode.Main_function_is_missing, undefined);
+            console.error(mainFuncExpr, `"${this.program.contractTirFuncName}"`);
+            this.error(DiagnosticCode.Contract_is_missing, undefined);
             return this.program;
         }
         if (!mainFuncExpr)
@@ -114,16 +124,16 @@ export class AstCompiler extends DiagnosticEmitter {
         return this.program;
     }
     // mutually recursive
-    async compileFile(path, isMain = false) {
+    async compileFile(path, isEntryFile = false) {
         const src = await this.getAbsoulteProjPathSource(path);
         if (!src)
             return;
         // parse imports first
-        await this.compileAllDeps(ResolveStackNode.entry(src), isMain);
+        await this.compileAllDeps(ResolveStackNode.entry(src), isEntryFile);
         // if there were errors
-        if (this.diagnostics.length > 0)
+        if (this.diagnostics.some(d => d.category === DiagnosticCategory.Error))
             return;
-        await this._compileParsedSource(src, isMain);
+        await this._compileParsedSource(src, isEntryFile);
         return src;
     }
     _srcDonelogUids = new Set();
@@ -131,7 +141,7 @@ export class AstCompiler extends DiagnosticEmitter {
      * translates the source AST statements
      * to TIR statements; and saves the result in `this.program`
      */
-    async _compileParsedSource(src, isMain = false) {
+    async _compileParsedSource(src, isEntryFile = false) {
         if (this._srcDonelogUids.has(src.uid))
             return;
         // clone array so we don't remove stmts from the original AST
@@ -146,7 +156,7 @@ export class AstCompiler extends DiagnosticEmitter {
         // collect top level **interface** declarations (NOT implementations)
         this._collectInterfaceDeclarations(stmts, topLevelScope, srcExports);
         // collects top level functions, methods (interface impls), and consts types
-        this._collectAllTopLevelSignatures(stmts, src.uid, topLevelScope, srcExports, isMain);
+        this._collectAllTopLevelSignatures(stmts, src.uid, topLevelScope, srcExports, isEntryFile);
         /*
         this._compileTopLevelFunctionsAndConsts(
             stmts,
@@ -158,8 +168,8 @@ export class AstCompiler extends DiagnosticEmitter {
         this.program.setExportedSymbols(src.absoluteProjPath, srcExports);
         this._srcDonelogUids.add(src.uid);
     }
-    _collectAllTopLevelSignatures(stmts, srcUid, topLevelScope, srcExports, isMain = false) {
-        for (let i = 0; i < stmts.length; i++) {
+    _collectAllTopLevelSignatures(stmts, srcUid, topLevelScope, srcExports, isEntryFile = false) {
+        top_level_stmts_iter: for (let i = 0; i < stmts.length; i++) {
             let stmt = stmts[i];
             let exported = false;
             let exportRange = undefined;
@@ -169,12 +179,60 @@ export class AstCompiler extends DiagnosticEmitter {
                 stmt = stmt.stmt;
             }
             if (!(stmt instanceof FuncDecl
-                || stmt instanceof TypeImplementsStmt))
+                || stmt instanceof TypeImplementsStmt
+                || stmt instanceof ContractDecl
+                || stmt instanceof VarStmt))
+                continue;
+            if (stmt instanceof VarStmt) {
+                const nDecl = stmt.declarations.length;
+                for (let dI = 0; dI < nDecl; dI++) {
+                    const decl = stmt.declarations[dI];
+                    if (!(decl.isConst()
+                        && decl instanceof SimpleVarDecl)) {
+                        this.error(DiagnosticCode.Only_constants_can_be_declared_outside_of_a_function, stmt.range);
+                        // remove from array so we don't process it again
+                        void stmts.splice(i, 1);
+                        i--;
+                        continue top_level_stmts_iter;
+                    }
+                    this._collectTopLevelConst(decl, srcUid, topLevelScope, srcExports, exportRange, isEntryFile);
+                }
+                // remove from array so we don't process it again
+                void stmts.splice(i, 1);
+                i--;
                 continue;
+            }
             if (exported && stmt instanceof TypeImplementsStmt)
                 this.error(DiagnosticCode.Interface_implementations_cannot_be_exported, exportRange ?? stmt.range);
+            if (stmt instanceof ContractDecl) {
+                // ignore contract declarations if not in the entry file
+                if (!isEntryFile) {
+                    // remove from array so we don't process it again
+                    void stmts.splice(i, 1);
+                    i--;
+                    continue;
+                }
+                const funcDeclContract = this._contractDeclToFuncDecl(stmt);
+                if (!funcDeclContract) {
+                    // remove from array so we don't process it again
+                    void stmts.splice(i, 1);
+                    i--;
+                    continue;
+                }
+                this._collectTopLevelFuncDeclSig(funcDeclContract, srcUid, topLevelScope, srcExports, exportRange, 
+                // set main
+                true // isEntryFile
+                );
+                // remove from array so we don't process it again
+                void stmts.splice(i, 1);
+                i--;
+                continue;
+            }
             if (stmt instanceof FuncDecl)
-                this._collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports, exportRange, isMain);
+                this._collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports, exportRange, 
+                // don't set main
+                false // isEntryFile
+                );
             else
                 this._collectInterfaceImplSigs(stmt, srcUid, topLevelScope);
             // remove from array so we don't process it again
@@ -223,7 +281,22 @@ export class AstCompiler extends DiagnosticEmitter {
             this.program.functions.set(tirMethodName, funcExpr);
         }
     }
-    _collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isMain = false) {
+    _collectTopLevelConst(decl, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isEntryFile = false) {
+        const astName = decl.name.text;
+        // const tirConstName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astName + "_" + srcUid;
+        const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
+        const tirVarDecl = _compileSimpleVarDecl(declContext, decl, undefined // type hint (extracted from init expr if explicit, or inferred from expression)
+        );
+        if (!tirVarDecl)
+            return undefined;
+        if (!tirVarDecl.initExpr)
+            return this.error(DiagnosticCode._const_declarations_must_be_initialized, tirVarDecl.range);
+        if (this.program.constants.has(astName)) {
+            throw new Error("not_implemented::AstCompiler::_collectTopLevelConst::const_redefinition_check");
+        }
+        this.program.constants.set(astName, tirVarDecl);
+    }
+    _collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isEntryFile = false) {
         const astFuncExpr = stmt.expr;
         const astFuncName = astFuncExpr.name.text;
         const tirFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astFuncName + "_" + srcUid;
@@ -245,9 +318,8 @@ export class AstCompiler extends DiagnosticEmitter {
                 srcExports.functions.set(astFuncName, tirFuncName);
             }
         }
-        if (isMain
-            && this.program.contractTirFuncName === ""
-            && astFuncExpr.name.text === "main")
+        if (isEntryFile
+            && this.program.contractTirFuncName === "")
             this.program.contractTirFuncName = tirFuncName;
     }
     _collectInterfaceDeclarations(stmts, topLevelScope, srcExports) {
@@ -277,6 +349,9 @@ export class AstCompiler extends DiagnosticEmitter {
             i--;
         }
     }
+    registerInternalTypeDecl(decl) {
+        this._collectTypeDeclarations([decl], "", this.preludeScope, this.preludeScope);
+    }
     _collectTypeDeclarations(stmts, srcUid, topLevelScope, srcExports) {
         for (let i = 0; i < stmts.length; i++) {
             let stmt = stmts[i];
@@ -298,9 +373,9 @@ export class AstCompiler extends DiagnosticEmitter {
                 continue; // ignore type decl
             // define on program
             if (tirTypes.sop)
-                this.program.types.set(tirTypes.sop.toConcreteTirTypeName(), tirTypes.sop);
+                this.program.registerType(tirTypes.sop);
             if (tirTypes.data)
-                this.program.types.set(tirTypes.data.toConcreteTirTypeName(), tirTypes.data);
+                this.program.registerType(tirTypes.data);
             const sopTirName = tirTypes.sop?.toTirTypeKey() ?? tirTypes.data.toTirTypeKey();
             const dataTirName = tirTypes.data?.toTirTypeKey();
             const possibleTirTypes = Object.freeze({
@@ -375,7 +450,7 @@ export class AstCompiler extends DiagnosticEmitter {
             else
                 this.warning(DiagnosticCode.Type_0_cannot_be_encoded_as_data_but_it_has_a_runtime_encoding_Use_runtime_keyword_modifier_for_the_declaration, stmt.range, stmt.name.text);
         }
-        return sop || data ? { sop, data, methodsNames } : undefined;
+        return (sop || data) ? { sop, data, methodsNames } : undefined;
     }
     _compileTypeAliasDecl(stmt, srcUid, topLevelScope) {
         if (stmt.typeParams.length > 0)
@@ -400,7 +475,6 @@ export class AstCompiler extends DiagnosticEmitter {
             if (!(stmt instanceof ImportStmt))
                 continue;
             const importAbsPath = getAbsolutePath(stmt.fromPath.string, srcAbsPath) ?? "";
-            // console.log(projAbsoultePath, [ ...this.program.files.keys() ]);
             const importedSymbols = this.program.getExportedSymbols(importAbsPath);
             if (!importedSymbols) {
                 return this.error(DiagnosticCode.File_0_not_found, stmt.fromPath.range, importAbsPath // stmt.fromPath.string
@@ -456,7 +530,7 @@ export class AstCompiler extends DiagnosticEmitter {
     /**
      * @returns `true` if there were no errors. `false` otherwise.
      */
-    async compileAllDeps(_resolveStackNode, isMain = false) {
+    async compileAllDeps(_resolveStackNode, isEntryFile = false) {
         const src = _resolveStackNode.dependent; // resolveStackNode instanceof ResolveStackNode ? source.dependent : source;
         const resolveStack = _resolveStackNode; // source instanceof ResolveStackNode ? source : new ResolveStackNode( undefined, src );
         const isCycle = resolveStack.parent?.includesInternalPath(src.absoluteProjPath) ?? false;
@@ -484,7 +558,7 @@ export class AstCompiler extends DiagnosticEmitter {
             if (!await this.compileAllDeps(nextStack))
                 return false;
         }
-        this._compileParsedSource(src, isMain);
+        this._compileParsedSource(src, isEntryFile);
         return true;
     }
     importPathsFromStmts(stmts, requestingPath) {
@@ -534,6 +608,36 @@ export class AstCompiler extends DiagnosticEmitter {
         }
         ;
     }
+    _contractDeclToFuncDecl(contractDecl) {
+        const funcName = getUniqueInternalName(contractDecl.name.text);
+        const paramsInternalNamesMap = new Map();
+        const funcParams = new Array(contractDecl.params.length + 1);
+        for (const [i, param] of contractDecl.params.entries()) {
+            if (!param.type) {
+                this.error(DiagnosticCode.Type_expected, param.name.range.atEnd());
+                return undefined;
+            }
+            const astType = param.type;
+            const astName = param.name.text;
+            if (paramsInternalNamesMap.has(astName)) {
+                this.error(DiagnosticCode.Duplicate_identifier_0, param.name.range, param.name.text);
+                return undefined;
+            }
+            const internalName = getUniqueInternalName(param.name.text);
+            paramsInternalNamesMap.set(astName, internalName);
+            funcParams[i] = new SimpleVarDecl(new Identifier(internalName, param.name.range), astType, undefined, // initExpr
+            CommonFlags.Const, param.range);
+        }
+        const scriptContextName = getUniqueInternalName("ctx");
+        funcParams[contractDecl.params.length] = new SimpleVarDecl(new Identifier(scriptContextName, contractDecl.name.range), new AstNamedTypeExpr(new Identifier("ScriptContext", contractDecl.name.range), [], contractDecl.name.range), undefined, // initExpr
+        CommonFlags.Const, contractDecl.name.range);
+        const funcSig = new AstFuncType(funcParams, new AstVoidType(contractDecl.name.range), contractDecl.name.range);
+        const contractBody = _deriveContractBody(this, contractDecl, paramsInternalNamesMap, scriptContextName);
+        if (!contractBody)
+            return undefined;
+        return new FuncDecl(new FuncExpr(new Identifier(funcName, contractDecl.name.range), CommonFlags.None, [], // typeParameters
+        funcSig, contractBody, ArrowKind.None, contractDecl.range));
+    }
 }
 function isImportStmtLike(stmt) {
     return (stmt instanceof ImportStmt

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

@@ -0,0 +1,10 @@
+import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
+import { ContractDecl } from "../../../../ast/nodes/statements/declarations/ContractDecl.js";
+import { AstCompiler } from "../../AstCompiler.js";
+/**
+ *
+ * only returns the body of the main function
+ *
+ * function arguments (parameters and script context) must be handled outside
+ */
+export declare function _deriveContractBody(compiler: AstCompiler, contractDecl: ContractDecl, paramsInternalNamesMap: Map<string, string>, scriptContextName: string): BlockStmt | undefined;