cashc 0.9.2 → 0.10.0-next.0

package/dist/artifact/Artifact.d.ts

@@ -1,3 +1,9 @@
-import { Artifact, Script } from '@cashscript/utils';
+import { Artifact, LogEntry, RequireMessage, Script } from '@cashscript/utils';
 import { Ast } from '../ast/AST.js';
-export declare function generateArtifact(ast: Ast, script: Script, source: string): Artifact;
+export declare function generateArtifact(ast: Ast, script: Script, source: string, debug: {
+    script: Script;
+    sourceMap: string;
+    logs: LogEntry[];
+    requireMessages: RequireMessage[];
+}): Artifact;
+export declare function stripArtifact(artifact: Artifact): Omit<Artifact, 'debug'>;

package/dist/artifact/Artifact.js

@@ -1,6 +1,7 @@
-import { scriptToAsm } from '@cashscript/utils';
+import { scriptToAsm, scriptToBytecode, } from '@cashscript/utils';
 import { version } from '../index.js';
-export function generateArtifact(ast, script, source) {
+import { binToHex } from '@bitauth/libauth';
+export function generateArtifact(ast, script, source, debug) {
     const { contract } = ast;
     const constructorInputs = contract.parameters
         .map((parameter) => ({ name: parameter.name, type: parameter.type.toString() }));
@@ -12,12 +13,19 @@ export function generateArtifact(ast, script, source) {
         })),
     }));
     const bytecode = scriptToAsm(script);
+    const debugBytecode = binToHex(scriptToBytecode(debug.script));
     return {
         contractName: contract.name,
         constructorInputs,
         abi,
         bytecode,
         source,
+        debug: {
+            bytecode: debugBytecode,
+            sourceMap: debug.sourceMap,
+            logs: debug.logs,
+            requireMessages: debug.requireMessages,
+        },
         compiler: {
             name: 'cashc',
             version,
@@ -25,4 +33,9 @@ export function generateArtifact(ast, script, source) {
         updatedAt: new Date().toISOString(),
     };
 }
+// strip verbose debug info from artifact for production use
+export function stripArtifact(artifact) {
+    delete artifact.debug;
+    return artifact;
+}
 //# sourceMappingURL=Artifact.js.map

package/dist/ast/AST.d.ts

@@ -81,12 +81,14 @@ export declare class AssignNode extends StatementNode {
 export declare class TimeOpNode extends StatementNode {
     timeOp: TimeOp;
     expression: ExpressionNode;
-    constructor(timeOp: TimeOp, expression: ExpressionNode);
+    message?: string | undefined;
+    constructor(timeOp: TimeOp, expression: ExpressionNode, message?: string | undefined);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class RequireNode extends StatementNode {
     expression: ExpressionNode;
-    constructor(expression: ExpressionNode);
+    message?: string | undefined;
+    constructor(expression: ExpressionNode, message?: string | undefined);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class BranchNode extends StatementNode {
@@ -182,3 +184,14 @@ export declare class HexLiteralNode extends LiteralNode {
     constructor(value: Uint8Array);
     accept<T>(visitor: AstVisitor<T>): T;
 }
+export declare class ConsoleStatementNode extends Node {
+    parameters: ConsoleParameterNode[];
+    constructor(parameters: ConsoleParameterNode[]);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
+export declare class ConsoleParameterNode extends Node {
+    message?: string | undefined;
+    identifier?: string | undefined;
+    constructor(message?: string | undefined, identifier?: string | undefined);
+    accept<T>(visitor: AstVisitor<T>): T;
+}

package/dist/ast/AST.js

@@ -79,19 +79,21 @@ export class AssignNode extends StatementNode {
     }
 }
 export class TimeOpNode extends StatementNode {
-    constructor(timeOp, expression) {
+    constructor(timeOp, expression, message) {
         super();
         this.timeOp = timeOp;
         this.expression = expression;
+        this.message = message;
     }
     accept(visitor) {
         return visitor.visitTimeOp(this);
     }
 }
 export class RequireNode extends StatementNode {
-    constructor(expression) {
+    constructor(expression, message) {
         super();
         this.expression = expression;
+        this.message = message;
     }
     accept(visitor) {
         return visitor.visitRequire(this);
@@ -251,4 +253,23 @@ export class HexLiteralNode extends LiteralNode {
         return visitor.visitHexLiteral(this);
     }
 }
+export class ConsoleStatementNode extends Node {
+    constructor(parameters) {
+        super();
+        this.parameters = parameters;
+    }
+    accept(visitor) {
+        return visitor.visitConsoleStatement(this);
+    }
+}
+export class ConsoleParameterNode extends Node {
+    constructor(message, identifier) {
+        super();
+        this.message = message;
+        this.identifier = identifier;
+    }
+    accept(visitor) {
+        return visitor.visitConsoleParameter(this);
+    }
+}
 //# sourceMappingURL=AST.js.map

package/dist/ast/AstBuilder.d.ts

@@ -1,7 +1,7 @@
 import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor.js';
 import { ParseTree } from 'antlr4ts/tree/ParseTree.js';
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode } from './AST.js';
-import type { ContractDefinitionContext, FunctionDefinitionContext, VariableDefinitionContext, TupleAssignmentContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, InstantiationContext, NullaryOpContext, UnaryIntrospectionOpContext } from '../grammar/CashScriptParser.js';
+import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode } from './AST.js';
+import type { ContractDefinitionContext, FunctionDefinitionContext, VariableDefinitionContext, TupleAssignmentContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, InstantiationContext, NullaryOpContext, UnaryIntrospectionOpContext, ConsoleStatementContext, ConsoleParameterContext } from '../grammar/CashScriptParser.js';
 import type { CashScriptVisitor } from '../grammar/CashScriptVisitor.js';
 export default class AstBuilder extends AbstractParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
     private tree;
@@ -39,4 +39,6 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     createStringLiteral(ctx: LiteralContext): StringLiteralNode;
     createDateLiteral(ctx: LiteralContext): IntLiteralNode;
     createHexLiteral(ctx: LiteralContext): HexLiteralNode;
+    visitConsoleStatement(ctx: ConsoleStatementContext): ConsoleStatementNode;
+    visitConsoleParameter(ctx: ConsoleParameterContext): ConsoleParameterNode;
 }

package/dist/ast/AstBuilder.js

@@ -2,7 +2,7 @@ import { hexToBin } from '@bitauth/libauth';
 import { parseType } from '@cashscript/utils';
 import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor.js';
 import semver from 'semver';
-import { SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, } from './AST.js';
+import { SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode, } from './AST.js';
 import { Location } from './Location.js';
 import { NumberUnit, } from './Globals.js';
 import { getPragmaName, PragmaName, getVersionOpFromCtx } from './Pragma.js';
@@ -95,13 +95,15 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
     }
     visitTimeOpStatement(ctx) {
         const expression = this.visit(ctx.expression());
-        const timeOp = new TimeOpNode(ctx.TxVar().text, expression);
+        const message = ctx.StringLiteral() && this.createStringLiteral(ctx)?.value;
+        const timeOp = new TimeOpNode(ctx.TxVar().text, expression, message);
         timeOp.location = Location.fromCtx(ctx);
         return timeOp;
     }
     visitRequireStatement(ctx) {
         const expression = this.visit(ctx.expression());
-        const require = new RequireNode(expression);
+        const message = ctx.StringLiteral() && this.createStringLiteral(ctx)?.value;
+        const require = new RequireNode(expression, message);
         require.location = Location.fromCtx(ctx);
         return require;
     }
@@ -261,5 +263,21 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         hexLiteral.location = Location.fromCtx(ctx);
         return hexLiteral;
     }
+    visitConsoleStatement(ctx) {
+        const parameters = ctx.consoleParameterList().consoleParameter().map((p) => this.visit(p));
+        const node = new ConsoleStatementNode(parameters);
+        node.location = Location.fromCtx(ctx);
+        return node;
+    }
+    visitConsoleParameter(ctx) {
+        let message = (ctx.BooleanLiteral() ?? ctx.HexLiteral() ?? ctx.NumberLiteral() ?? ctx.StringLiteral())?.text;
+        if (message?.[0] === '"') {
+            message = message.slice(1, -1);
+        }
+        const identifier = ctx.Identifier()?.text;
+        const node = new ConsoleParameterNode(message, identifier);
+        node.location = Location.fromCtx(ctx);
+        return node;
+    }
 }
 //# sourceMappingURL=AstBuilder.js.map

package/dist/ast/AstTraversal.d.ts

@@ -1,4 +1,4 @@
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode } from './AST.js';
+import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode } from './AST.js';
 import AstVisitor from './AstVisitor.js';
 export default class AstTraversal extends AstVisitor<Node> {
     visitSourceFile(node: SourceFileNode): Node;
@@ -25,4 +25,6 @@ export default class AstTraversal extends AstVisitor<Node> {
     visitIntLiteral(node: IntLiteralNode): Node;
     visitStringLiteral(node: StringLiteralNode): Node;
     visitHexLiteral(node: HexLiteralNode): Node;
+    visitConsoleStatement(node: ConsoleStatementNode): Node;
+    visitConsoleParameter(node: ConsoleParameterNode): Node;
 }

package/dist/ast/AstTraversal.js

@@ -98,5 +98,12 @@ export default class AstTraversal extends AstVisitor {
     visitHexLiteral(node) {
         return node;
     }
+    visitConsoleStatement(node) {
+        node.parameters = this.visitList(node.parameters);
+        return node;
+    }
+    visitConsoleParameter(node) {
+        return node;
+    }
 }
 //# sourceMappingURL=AstTraversal.js.map

package/dist/ast/AstVisitor.d.ts

@@ -1,4 +1,4 @@
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode } from './AST.js';
+import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode } from './AST.js';
 export default abstract class AstVisitor<T> {
     abstract visitSourceFile(node: SourceFileNode): T;
     abstract visitContract(node: ContractNode): T;
@@ -24,6 +24,8 @@ export default abstract class AstVisitor<T> {
     abstract visitIntLiteral(node: IntLiteralNode): T;
     abstract visitStringLiteral(node: StringLiteralNode): T;
     abstract visitHexLiteral(node: HexLiteralNode): T;
+    abstract visitConsoleStatement(node: ConsoleStatementNode): T;
+    abstract visitConsoleParameter(node: ConsoleParameterNode): T;
     visit(node: Node): T;
     visitOptional(node?: Node): T | undefined;
     visitList(nodes: Node[]): T[];

package/dist/ast/Location.d.ts

@@ -1,11 +1,13 @@
 import type { ParserRuleContext } from 'antlr4ts/ParserRuleContext.js';
 import type { Token } from 'antlr4ts';
-export declare class Location {
+import { LocationI } from '@cashscript/utils';
+export declare class Location implements LocationI {
     start: Point;
     end: Point;
     constructor(start: Point, end: Point);
     static fromCtx(ctx: ParserRuleContext): Location | undefined;
     static fromToken(token: Token): Location | undefined;
+    static fromObject(object: LocationI): Location;
     text(code: string): string;
 }
 export declare class Point {

package/dist/ast/Location.js

@@ -16,6 +16,11 @@ export class Location {
         const end = new Point(token.line, token.charPositionInLine + textLength);
         return new Location(start, end);
     }
+    static fromObject(object) {
+        const start = new Point(object.start.line, object.start.column);
+        const end = new Point(object.end.line, object.end.column);
+        return new Location(start, end);
+    }
     text(code) {
         return code.slice(this.start.offset(code), this.end.offset(code));
     }

package/dist/compiler.js

@@ -14,16 +14,21 @@ export function compileString(code) {
     // Lexing + parsing
     let ast = parseCode(code);
     // Semantic analysis
-    ast = ast.accept(new SymbolTableTraversal());
+    const symbolTableTraversal = new SymbolTableTraversal();
+    ast = ast.accept(symbolTableTraversal);
     ast = ast.accept(new TypeCheckTraversal());
     ast = ast.accept(new EnsureFinalRequireTraversal());
     // Code generation
-    const traversal = new GenerateTargetTraversal();
+    const traversal = new GenerateTargetTraversal(symbolTableTraversal.logSymbols);
     ast = ast.accept(traversal);
-    const bytecode = traversal.output;
     // Bytecode optimisation
-    const optimisedBytecode = optimiseBytecode(bytecode);
-    return generateArtifact(ast, optimisedBytecode, code);
+    const optimisedBytecode = optimiseBytecode(traversal.output);
+    return generateArtifact(ast, optimisedBytecode, code, {
+        script: traversal.output,
+        sourceMap: traversal.souceMap,
+        logs: traversal.consoleLogs,
+        requireMessages: traversal.requireMessages,
+    });
 }
 export function compileFile(codeFile) {
     const code = fs.readFileSync(codeFile, { encoding: 'utf-8' });

package/dist/generation/GenerateTargetTraversal.d.ts

@@ -1,11 +1,19 @@
-import { Script } from '@cashscript/utils';
-import { ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, SourceFileNode, Node, InstantiationNode, TupleAssignmentNode, NullaryOpNode } from '../ast/AST.js';
+import { Script, LogEntry, RequireMessage } from '@cashscript/utils';
+import { ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, SourceFileNode, Node, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
-export default class GenerateTargetTraversal extends AstTraversal {
+import { Symbol } from '../ast/SymbolTable.js';
+export default class GenerateTargetTraversalWithLocation extends AstTraversal {
+    private logSymbols;
+    private locationData;
+    souceMap: string;
     output: Script;
     stack: string[];
+    consoleLogs: LogEntry[];
+    requireMessages: RequireMessage[];
     private scopeDepth;
     private currentFunction;
+    private constructorParameterCount;
+    constructor(logSymbols: Symbol[]);
     private emit;
     private pushToStack;
     private popFromStack;
@@ -15,17 +23,17 @@ export default class GenerateTargetTraversal extends AstTraversal {
     visitSourceFile(node: SourceFileNode): Node;
     visitContract(node: ContractNode): Node;
     visitFunctionDefinition(node: FunctionDefinitionNode): Node;
-    removeFinalVerify(): void;
-    cleanStack(): void;
+    removeFinalVerify(node: Node): void;
+    cleanStack(node: Node): void;
     visitParameter(node: ParameterNode): Node;
     visitVariableDefinition(node: VariableDefinitionNode): Node;
     visitTupleAssignment(node: TupleAssignmentNode): Node;
     visitAssign(node: AssignNode): Node;
-    emitReplace(index: number): void;
+    emitReplace(index: number, node: Node): void;
     visitTimeOp(node: TimeOpNode): Node;
     visitRequire(node: RequireNode): Node;
     visitBranch(node: BranchNode): Node;
-    removeScopedVariables(depthBeforeScope: number): void;
+    removeScopedVariables(depthBeforeScope: number, node: Node): void;
     visitCast(node: CastNode): Node;
     visitFunctionCall(node: FunctionCallNode): Node;
     visitMultiSig(node: FunctionCallNode): Node;
@@ -41,4 +49,5 @@ export default class GenerateTargetTraversal extends AstTraversal {
     visitIntLiteral(node: IntLiteralNode): Node;
     visitStringLiteral(node: StringLiteralNode): Node;
     visitHexLiteral(node: HexLiteralNode): Node;
+    visitConsoleStatement(node: ConsoleStatementNode): Node;
 }