cashc 0.6.5 → 0.7.0-next.0

package/README.md

@@ -26,13 +26,11 @@ npm install -g cashc
 Usage: cashc [options] [source_file]
 
 Options:
-  --output, -o   Specify a file to output the generated artifact.       [string]
-  --hex, -h      Compile the contract to hex format rather than a full artifact
-                                                                       [boolean]
-  --asm, -A      Compile the contract to ASM format rather than a full artifact
-                                                                       [boolean]
-  --opcount, -c  Display the number of opcodes in the compiled bytecode[boolean]
-  --size, -s     Display the size in bytes of the compiled bytecode    [boolean]
-  --help         Show help                                             [boolean]
-  --version      Show version number                                   [boolean]
+  -V, --version        Output the version number.
+  -o, --output <path>  Specify a file to output the generated artifact.
+  -h, --hex            Compile the contract to hex format rather than a full artifact.
+  -A, --asm            Compile the contract to ASM format rather than a full artifact.
+  -c, --opcount        Display the number of opcodes in the compiled bytecode.
+  -s, --size           Display the size in bytes of the compiled bytecode.
+  -?, --help           Display help
 ```

package/dist/main/Errors.d.ts

@@ -1,5 +1,5 @@
 import { Type, PrimitiveType } from '@cashscript/utils';
-import { IdentifierNode, FunctionDefinitionNode, VariableDefinitionNode, ParameterNode, Node, FunctionCallNode, BinaryOpNode, UnaryOpNode, TimeOpNode, CastNode, AssignNode, BranchNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, StatementNode, ContractNode } from './ast/AST';
+import { IdentifierNode, FunctionDefinitionNode, VariableDefinitionNode, ParameterNode, Node, FunctionCallNode, BinaryOpNode, UnaryOpNode, TimeOpNode, CastNode, AssignNode, BranchNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, StatementNode, ContractNode, ExpressionNode } from './ast/AST';
 import { Symbol, SymbolType } from './ast/SymbolTable';
 import { Location, Point } from './ast/Location';
 export declare class CashScriptError extends Error {
@@ -67,6 +67,9 @@ export declare class CastSizeError extends CashScriptError {
 export declare class AssignTypeError extends TypeError {
     constructor(node: AssignNode | VariableDefinitionNode);
 }
+export declare class TupleAssignmentError extends CashScriptError {
+    constructor(node: ExpressionNode);
+}
 export declare class ConstantConditionError extends CashScriptError {
     constructor(node: BranchNode | RequireNode, res: boolean);
 }
@@ -79,6 +82,3 @@ export declare class IndexOutOfBoundsError extends CashScriptError {
 export declare class VersionError extends Error {
     constructor(actual: string, constraint: string);
 }
-export declare class UnverifiedCovenantError extends CashScriptError {
-    constructor(node: IdentifierNode);
-}

package/dist/main/Errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnverifiedCovenantError = exports.VersionError = exports.IndexOutOfBoundsError = exports.ArrayElementError = exports.ConstantConditionError = exports.AssignTypeError = exports.CastSizeError = exports.CastTypeError = exports.UnsupportedTypeError = exports.UnequalTypeError = exports.InvalidParameterTypeError = exports.TypeError = exports.FinalRequireStatementError = exports.EmptyFunctionError = exports.EmptyContractError = exports.UnusedVariableError = exports.VariableRedefinitionError = exports.FunctionRedefinitionError = exports.RedefinitionError = exports.InvalidSymbolTypeError = exports.UndefinedReferenceError = exports.ParseError = exports.CashScriptError = void 0;
+exports.VersionError = exports.IndexOutOfBoundsError = exports.ArrayElementError = exports.ConstantConditionError = exports.TupleAssignmentError = exports.AssignTypeError = exports.CastSizeError = exports.CastTypeError = exports.UnsupportedTypeError = exports.UnequalTypeError = exports.InvalidParameterTypeError = exports.TypeError = exports.FinalRequireStatementError = exports.EmptyFunctionError = exports.EmptyContractError = exports.UnusedVariableError = exports.VariableRedefinitionError = exports.FunctionRedefinitionError = exports.RedefinitionError = exports.InvalidSymbolTypeError = exports.UndefinedReferenceError = exports.ParseError = exports.CashScriptError = void 0;
 const utils_1 = require("@cashscript/utils");
 const AST_1 = require("./ast/AST");
 const Location_1 = require("./ast/Location");
@@ -126,6 +126,10 @@ class UnsupportedTypeError extends TypeError {
         else if (node instanceof AST_1.UnaryOpNode && node.operator.startsWith('.')) {
             super(node, actual, expected, `Tried to access member '${node.operator}' on unsupported type '${actual}'`);
         }
+        else if (node instanceof AST_1.UnaryOpNode && node.operator.includes('[i]')) {
+            const [scope] = node.operator.split('[i]');
+            super(node, actual, expected, `Tried to index '${scope}''with unsupported type '${actual}'`);
+        }
         else if (node instanceof AST_1.UnaryOpNode) {
             super(node, actual, expected, `Tried to apply operator '${node.operator}' to unsupported type '${actual}'`);
         }
@@ -160,6 +164,12 @@ class AssignTypeError extends TypeError {
     }
 }
 exports.AssignTypeError = AssignTypeError;
+class TupleAssignmentError extends CashScriptError {
+    constructor(node) {
+        super(node, 'Expression must return a tuple to use destructuring');
+    }
+}
+exports.TupleAssignmentError = TupleAssignmentError;
 class ConstantConditionError extends CashScriptError {
     constructor(node, res) {
         super(node, `Condition always evaluates to ${res}`);
@@ -186,10 +196,4 @@ class VersionError extends Error {
     }
 }
 exports.VersionError = VersionError;
-class UnverifiedCovenantError extends CashScriptError {
-    constructor(node) {
-        super(node, `Covenant variable ${node.name} was used without un-nested signature check`);
-    }
-}
-exports.UnverifiedCovenantError = UnverifiedCovenantError;
 //# sourceMappingURL=Errors.js.map

package/dist/main/artifact/Artifact.js

@@ -9,7 +9,6 @@ function generateArtifact(ast, script, source) {
         .map((parameter) => ({ name: parameter.name, type: parameter.type.toString() }));
     const abi = contract.functions.map((func) => ({
         name: func.name,
-        covenant: func.preimageFields.length > 0,
         inputs: func.parameters.map((parameter) => ({
             name: parameter.name,
             type: parameter.type.toString(),

package/dist/main/ast/AST.d.ts

@@ -1,7 +1,7 @@
 import { Type } from '@cashscript/utils';
-import { TimeOp, PreimageField } from './Globals';
+import { TimeOp } from './Globals';
 import AstVisitor from './AstVisitor';
-import { BinaryOperator, UnaryOperator } from './Operator';
+import { BinaryOperator, NullaryOperator, UnaryOperator } from './Operator';
 import { Location } from './Location';
 import { SymbolTable, Symbol } from './SymbolTable';
 export declare type Ast = SourceFileNode;
@@ -32,10 +32,9 @@ export declare class FunctionDefinitionNode extends Node implements Named {
     name: string;
     parameters: ParameterNode[];
     body: BlockNode;
-    preimageFields: PreimageField[];
     symbolTable?: SymbolTable;
     opRolls: Map<string, IdentifierNode>;
-    constructor(name: string, parameters: ParameterNode[], body: BlockNode, preimageFields: PreimageField[]);
+    constructor(name: string, parameters: ParameterNode[], body: BlockNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class ParameterNode extends Node implements Named, Typed {
@@ -53,6 +52,25 @@ export declare class VariableDefinitionNode extends StatementNode implements Nam
     constructor(type: Type, name: string, expression: ExpressionNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
+export declare class TupleAssignmentNode extends StatementNode {
+    var1: {
+        name: string;
+        type: Type;
+    };
+    var2: {
+        name: string;
+        type: Type;
+    };
+    tuple: ExpressionNode;
+    constructor(var1: {
+        name: string;
+        type: Type;
+    }, var2: {
+        name: string;
+        type: Type;
+    }, tuple: ExpressionNode);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
 export declare class AssignNode extends StatementNode {
     identifier: IdentifierNode;
     expression: ExpressionNode;
@@ -124,6 +142,11 @@ export declare class UnaryOpNode extends ExpressionNode {
     constructor(operator: UnaryOperator, expression: ExpressionNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
+export declare class NullaryOpNode extends ExpressionNode {
+    operator: NullaryOperator;
+    constructor(operator: NullaryOperator);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
 export declare class ArrayNode extends ExpressionNode {
     elements: ExpressionNode[];
     constructor(elements: ExpressionNode[]);

package/dist/main/ast/AST.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HexLiteralNode = exports.StringLiteralNode = exports.IntLiteralNode = exports.BoolLiteralNode = exports.LiteralNode = exports.IdentifierNode = exports.ArrayNode = exports.UnaryOpNode = exports.BinaryOpNode = exports.TupleIndexOpNode = exports.InstantiationNode = exports.FunctionCallNode = exports.CastNode = exports.ExpressionNode = exports.BlockNode = exports.BranchNode = exports.RequireNode = exports.TimeOpNode = exports.AssignNode = exports.VariableDefinitionNode = exports.StatementNode = exports.ParameterNode = exports.FunctionDefinitionNode = exports.ContractNode = exports.SourceFileNode = exports.Node = void 0;
+exports.HexLiteralNode = exports.StringLiteralNode = exports.IntLiteralNode = exports.BoolLiteralNode = exports.LiteralNode = exports.IdentifierNode = exports.ArrayNode = exports.NullaryOpNode = exports.UnaryOpNode = exports.BinaryOpNode = exports.TupleIndexOpNode = exports.InstantiationNode = exports.FunctionCallNode = exports.CastNode = exports.ExpressionNode = exports.BlockNode = exports.BranchNode = exports.RequireNode = exports.TimeOpNode = exports.AssignNode = exports.TupleAssignmentNode = exports.VariableDefinitionNode = exports.StatementNode = exports.ParameterNode = exports.FunctionDefinitionNode = exports.ContractNode = exports.SourceFileNode = exports.Node = void 0;
 const utils_1 = require("@cashscript/utils");
 class Node {
 }
@@ -28,12 +28,11 @@ class ContractNode extends Node {
 }
 exports.ContractNode = ContractNode;
 class FunctionDefinitionNode extends Node {
-    constructor(name, parameters, body, preimageFields) {
+    constructor(name, parameters, body) {
         super();
         this.name = name;
         this.parameters = parameters;
         this.body = body;
-        this.preimageFields = preimageFields;
         this.opRolls = new Map();
     }
     accept(visitor) {
@@ -67,6 +66,18 @@ class VariableDefinitionNode extends StatementNode {
     }
 }
 exports.VariableDefinitionNode = VariableDefinitionNode;
+class TupleAssignmentNode extends StatementNode {
+    constructor(var1, var2, tuple) {
+        super();
+        this.var1 = var1;
+        this.var2 = var2;
+        this.tuple = tuple;
+    }
+    accept(visitor) {
+        return visitor.visitTupleAssignment(this);
+    }
+}
+exports.TupleAssignmentNode = TupleAssignmentNode;
 class AssignNode extends StatementNode {
     constructor(identifier, expression) {
         super();
@@ -192,6 +203,16 @@ class UnaryOpNode extends ExpressionNode {
     }
 }
 exports.UnaryOpNode = UnaryOpNode;
+class NullaryOpNode extends ExpressionNode {
+    constructor(operator) {
+        super();
+        this.operator = operator;
+    }
+    accept(visitor) {
+        return visitor.visitNullaryOp(this);
+    }
+}
+exports.NullaryOpNode = NullaryOpNode;
 class ArrayNode extends ExpressionNode {
     constructor(elements) {
         super();

package/dist/main/ast/AstBuilder.d.ts

@@ -1,12 +1,11 @@
 import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
 import { ParseTree } from 'antlr4ts/tree/ParseTree';
-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 } from './AST';
-import { ContractDefinitionContext, FunctionDefinitionContext, VariableDefinitionContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, PreimageFieldContext, InstantiationContext } from '../grammar/CashScriptParser';
+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';
+import { 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';
 import { CashScriptVisitor } from '../grammar/CashScriptVisitor';
 export default class AstBuilder extends AbstractParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
     private tree;
     constructor(tree: ParseTree);
-    private preimageFields;
     defaultResult(): Node;
     build(): Node;
     visitSourceFile(ctx: SourceFileContext): SourceFileNode;
@@ -15,6 +14,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     visitFunctionDefinition(ctx: FunctionDefinitionContext): FunctionDefinitionNode;
     visitParameter(ctx: ParameterContext): ParameterNode;
     visitVariableDefinition(ctx: VariableDefinitionContext): VariableDefinitionNode;
+    visitTupleAssignment(ctx: TupleAssignmentContext): TupleAssignmentNode;
     visitAssignStatement(ctx: AssignStatementContext): AssignNode;
     visitTimeOpStatement(ctx: TimeOpStatementContext): TimeOpNode;
     visitRequireStatement(ctx: RequireStatementContext): RequireNode;
@@ -26,10 +26,11 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     visitFunctionCall(ctx: FunctionCallContext): FunctionCallNode;
     visitInstantiation(ctx: InstantiationContext): InstantiationNode;
     visitTupleIndexOp(ctx: TupleIndexOpContext): TupleIndexOpNode;
+    visitNullaryOp(ctx: NullaryOpContext): NullaryOpNode;
+    visitUnaryIntrospectionOp(ctx: UnaryIntrospectionOpContext): UnaryOpNode;
     visitUnaryOp(ctx: UnaryOpContext): UnaryOpNode;
     visitBinaryOp(ctx: BinaryOpContext): BinaryOpNode;
     visitArray(ctx: ArrayContext): ArrayNode;
-    visitPreimageField(ctx: PreimageFieldContext): IdentifierNode;
     visitIdentifier(ctx: IdentifierContext): IdentifierNode;
     visitLiteralExpression(ctx: LiteralExpressionContext): LiteralNode;
     createLiteral(ctx: LiteralContext): LiteralNode;

package/dist/main/ast/AstBuilder.js

@@ -56,15 +56,12 @@ class AstBuilder extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return contract;
     }
     visitFunctionDefinition(ctx) {
-        this.preimageFields = [];
         const name = ctx.Identifier().text;
         const parameters = ctx.parameterList().parameter().map((p) => this.visit(p));
         const statements = ctx.statement().map((s) => this.visit(s));
         const block = new AST_1.BlockNode(statements);
         block.location = Location_1.Location.fromCtx(ctx);
-        // Filter duplicate preimage fields
-        const preimageFields = [...this.preimageFields].filter((v, i, a) => a.indexOf(v) === i);
-        const functionDefinition = new AST_1.FunctionDefinitionNode(name, parameters, block, preimageFields);
+        const functionDefinition = new AST_1.FunctionDefinitionNode(name, parameters, block);
         functionDefinition.location = Location_1.Location.fromCtx(ctx);
         return functionDefinition;
     }
@@ -83,6 +80,15 @@ class AstBuilder extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         variableDefinition.location = Location_1.Location.fromCtx(ctx);
         return variableDefinition;
     }
+    visitTupleAssignment(ctx) {
+        const expression = this.visit(ctx.expression());
+        const names = ctx.Identifier();
+        const types = ctx.typeName();
+        const [var1, var2] = names.map((name, i) => ({ name: name.text, type: utils_1.parseType(types[i].text) }));
+        const tupleAssignment = new AST_1.TupleAssignmentNode(var1, var2, expression);
+        tupleAssignment.location = Location_1.Location.fromCtx(ctx);
+        return tupleAssignment;
+    }
     visitAssignStatement(ctx) {
         const identifier = new AST_1.IdentifierNode(ctx.Identifier().text);
         identifier.location = Location_1.Location.fromToken(ctx.Identifier().symbol);
@@ -154,6 +160,19 @@ class AstBuilder extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         tupleIndexOp.location = Location_1.Location.fromCtx(ctx);
         return tupleIndexOp;
     }
+    visitNullaryOp(ctx) {
+        const operator = ctx.text;
+        const nullaryOp = new AST_1.NullaryOpNode(operator);
+        nullaryOp.location = Location_1.Location.fromCtx(ctx);
+        return nullaryOp;
+    }
+    visitUnaryIntrospectionOp(ctx) {
+        const operator = `${ctx._scope.text}[i]${ctx._op.text}`;
+        const expression = this.visit(ctx.expression());
+        const unaryOp = new AST_1.UnaryOpNode(operator, expression);
+        unaryOp.location = Location_1.Location.fromCtx(ctx);
+        return unaryOp;
+    }
     visitUnaryOp(ctx) {
         const operator = ctx._op.text;
         const expression = this.visit(ctx.expression());
@@ -175,13 +194,6 @@ class AstBuilder extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         array.location = Location_1.Location.fromCtx(ctx);
         return array;
     }
-    visitPreimageField(ctx) {
-        const field = ctx.PreimageField().text;
-        this.preimageFields.push(field);
-        const identifier = new AST_1.IdentifierNode(field);
-        identifier.location = Location_1.Location.fromCtx(ctx);
-        return identifier;
-    }
     visitIdentifier(ctx) {
         const identifier = new AST_1.IdentifierNode(ctx.Identifier().text);
         identifier.location = Location_1.Location.fromCtx(ctx);

package/dist/main/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 } from './AST';
+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';
 import AstVisitor from './AstVisitor';
 export default class AstTraversal extends AstVisitor<Node> {
     visitSourceFile(node: SourceFileNode): Node;
@@ -6,6 +6,7 @@ export default class AstTraversal extends AstVisitor<Node> {
     visitFunctionDefinition(node: FunctionDefinitionNode): Node;
     visitParameter(node: ParameterNode): Node;
     visitVariableDefinition(node: VariableDefinitionNode): Node;
+    visitTupleAssignment(node: TupleAssignmentNode): Node;
     visitAssign(node: AssignNode): Node;
     visitTimeOp(node: TimeOpNode): Node;
     visitRequire(node: RequireNode): Node;
@@ -17,6 +18,7 @@ export default class AstTraversal extends AstVisitor<Node> {
     visitTupleIndexOp(node: TupleIndexOpNode): Node;
     visitBinaryOp(node: BinaryOpNode): Node;
     visitUnaryOp(node: UnaryOpNode): Node;
+    visitNullaryOp(node: NullaryOpNode): Node;
     visitArray(node: ArrayNode): Node;
     visitIdentifier(node: IdentifierNode): Node;
     visitBoolLiteral(node: BoolLiteralNode): Node;

package/dist/main/ast/AstTraversal.js

@@ -26,6 +26,10 @@ class AstTraversal extends AstVisitor_1.default {
         node.expression = this.visit(node.expression);
         return node;
     }
+    visitTupleAssignment(node) {
+        node.tuple = this.visit(node.tuple);
+        return node;
+    }
     visitAssign(node) {
         node.identifier = this.visit(node.identifier);
         node.expression = this.visit(node.expression);
@@ -77,6 +81,9 @@ class AstTraversal extends AstVisitor_1.default {
         node.expression = this.visit(node.expression);
         return node;
     }
+    visitNullaryOp(node) {
+        return node;
+    }
     visitArray(node) {
         node.elements = this.visitList(node.elements);
         return node;

package/dist/main/ast/AstVisitor.d.ts

@@ -1,10 +1,11 @@
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode } from './AST';
+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';
 export default abstract class AstVisitor<T> {
     abstract visitSourceFile(node: SourceFileNode): T;
     abstract visitContract(node: ContractNode): T;
     abstract visitFunctionDefinition(node: FunctionDefinitionNode): T;
     abstract visitParameter(node: ParameterNode): T;
     abstract visitVariableDefinition(node: VariableDefinitionNode): T;
+    abstract visitTupleAssignment(node: TupleAssignmentNode): T;
     abstract visitAssign(node: AssignNode): T;
     abstract visitTimeOp(node: TimeOpNode): T;
     abstract visitRequire(node: RequireNode): T;
@@ -16,6 +17,7 @@ export default abstract class AstVisitor<T> {
     abstract visitTupleIndexOp(node: TupleIndexOpNode): T;
     abstract visitBinaryOp(node: BinaryOpNode): T;
     abstract visitUnaryOp(node: UnaryOpNode): T;
+    abstract visitNullaryOp(node: NullaryOpNode): T;
     abstract visitArray(node: ArrayNode): T;
     abstract visitIdentifier(node: IdentifierNode): T;
     abstract visitBoolLiteral(node: BoolLiteralNode): T;

package/dist/main/ast/Globals.d.ts

@@ -21,20 +21,8 @@ export declare enum TimeOp {
     CHECK_LOCKTIME = "tx.time"
 }
 export declare enum Class {
-    OUTPUT_P2SH = "OutputP2SH",
-    OUTPUT_P2PKH = "OutputP2PKH",
-    OUTPUT_NULLDATA = "OutputNullData"
-}
-export declare enum PreimageField {
-    VERSION = "tx.version",
-    HASHPREVOUTS = "tx.hashPrevouts",
-    HASHSEQUENCE = "tx.hashSequence",
-    OUTPOINT = "tx.outpoint",
-    BYTECODE = "tx.bytecode",
-    VALUE = "tx.value",
-    SEQUENCE = "tx.sequence",
-    HASHOUTPUTS = "tx.hashOutputs",
-    LOCKTIME = "tx.locktime",
-    HASHTYPE = "tx.hashtype"
+    LOCKING_BYTECODE_P2SH = "LockingBytecodeP2SH",
+    LOCKING_BYTECODE_P2PKH = "LockingBytecodeP2PKH",
+    LOCKING_BYTECODE_NULLDATA = "LockingBytecodeNullData"
 }
 export declare const GLOBAL_SYMBOL_TABLE: SymbolTable;

package/dist/main/ast/Globals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLOBAL_SYMBOL_TABLE = exports.PreimageField = exports.Class = exports.TimeOp = exports.GlobalFunction = exports.NumberUnit = void 0;
+exports.GLOBAL_SYMBOL_TABLE = exports.Class = exports.TimeOp = exports.GlobalFunction = exports.NumberUnit = void 0;
 const utils_1 = require("@cashscript/utils");
 const SymbolTable_1 = require("./SymbolTable");
 exports.NumberUnit = {
@@ -37,39 +37,15 @@ var TimeOp;
 })(TimeOp = exports.TimeOp || (exports.TimeOp = {}));
 var Class;
 (function (Class) {
-    Class["OUTPUT_P2SH"] = "OutputP2SH";
-    Class["OUTPUT_P2PKH"] = "OutputP2PKH";
-    Class["OUTPUT_NULLDATA"] = "OutputNullData";
+    Class["LOCKING_BYTECODE_P2SH"] = "LockingBytecodeP2SH";
+    Class["LOCKING_BYTECODE_P2PKH"] = "LockingBytecodeP2PKH";
+    Class["LOCKING_BYTECODE_NULLDATA"] = "LockingBytecodeNullData";
 })(Class = exports.Class || (exports.Class = {}));
-var PreimageField;
-(function (PreimageField) {
-    PreimageField["VERSION"] = "tx.version";
-    PreimageField["HASHPREVOUTS"] = "tx.hashPrevouts";
-    PreimageField["HASHSEQUENCE"] = "tx.hashSequence";
-    PreimageField["OUTPOINT"] = "tx.outpoint";
-    PreimageField["BYTECODE"] = "tx.bytecode";
-    PreimageField["VALUE"] = "tx.value";
-    PreimageField["SEQUENCE"] = "tx.sequence";
-    PreimageField["HASHOUTPUTS"] = "tx.hashOutputs";
-    PreimageField["LOCKTIME"] = "tx.locktime";
-    PreimageField["HASHTYPE"] = "tx.hashtype";
-})(PreimageField = exports.PreimageField || (exports.PreimageField = {}));
 exports.GLOBAL_SYMBOL_TABLE = new SymbolTable_1.SymbolTable();
-// Preimage fields
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.VERSION, new utils_1.BytesType(4)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.HASHPREVOUTS, new utils_1.BytesType(32)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.HASHSEQUENCE, new utils_1.BytesType(32)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.OUTPOINT, new utils_1.BytesType(36)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.BYTECODE, new utils_1.BytesType()));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.VALUE, new utils_1.BytesType(8)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.SEQUENCE, new utils_1.BytesType(4)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.HASHOUTPUTS, new utils_1.BytesType(32)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.LOCKTIME, new utils_1.BytesType(4)));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.global(PreimageField.HASHTYPE, new utils_1.BytesType(4)));
 // Classes
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.OUTPUT_P2SH, new utils_1.BytesType(32), [new utils_1.BytesType(8), new utils_1.BytesType(20)]));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.OUTPUT_P2PKH, new utils_1.BytesType(34), [new utils_1.BytesType(8), new utils_1.BytesType(20)]));
-exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.OUTPUT_NULLDATA, new utils_1.BytesType(), [new utils_1.ArrayType(new utils_1.BytesType())]));
+exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.LOCKING_BYTECODE_P2SH, new utils_1.BytesType(23), [new utils_1.BytesType(20)]));
+exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.LOCKING_BYTECODE_P2PKH, new utils_1.BytesType(25), [new utils_1.BytesType(20)]));
+exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.class(Class.LOCKING_BYTECODE_NULLDATA, new utils_1.BytesType(), [new utils_1.ArrayType(new utils_1.BytesType())]));
 // Global functions
 exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.function(GlobalFunction.ABS, utils_1.PrimitiveType.INT, [utils_1.PrimitiveType.INT]));
 exports.GLOBAL_SYMBOL_TABLE.set(SymbolTable_1.Symbol.function(GlobalFunction.MIN, utils_1.PrimitiveType.INT, [utils_1.PrimitiveType.INT, utils_1.PrimitiveType.INT]));

package/dist/main/ast/Operator.d.ts

@@ -1,10 +1,27 @@
+export declare enum NullaryOperator {
+    INPUT_INDEX = "this.activeInputIndex",
+    BYTECODE = "this.activeBytecode",
+    INPUT_COUNT = "tx.inputs.length",
+    OUTPUT_COUNT = "tx.outputs.length",
+    VERSION = "tx.version",
+    LOCKTIME = "tx.locktime"
+}
 export declare enum UnaryOperator {
     NOT = "!",
     NEGATE = "-",
     SIZE = ".length",
-    REVERSE = ".reverse()"
+    REVERSE = ".reverse()",
+    INPUT_VALUE = "tx.inputs[i].value",
+    INPUT_LOCKING_BYTECODE = "tx.inputs[i].lockingBytecode",
+    INPUT_OUTPOINT_HASH = "tx.inputs[i].outpointTransactionHash",
+    INPUT_OUTPOINT_INDEX = "tx.inputs[i].outpointIndex",
+    INPUT_UNLOCKING_BYTECODE = "tx.inputs[i].unlockingBytecode",
+    INPUT_SEQUENCE_NUMBER = "tx.inputs[i].sequenceNumber",
+    OUTPUT_VALUE = "tx.outputs[i].value",
+    OUTPUT_LOCKING_BYTECODE = "tx.outputs[i].lockingBytecode"
 }
 export declare enum BinaryOperator {
+    MUL = "*",
     DIV = "/",
     MOD = "%",
     PLUS = "+",

package/dist/main/ast/Operator.js

@@ -1,15 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryOperator = exports.UnaryOperator = void 0;
+exports.BinaryOperator = exports.UnaryOperator = exports.NullaryOperator = void 0;
+var NullaryOperator;
+(function (NullaryOperator) {
+    NullaryOperator["INPUT_INDEX"] = "this.activeInputIndex";
+    NullaryOperator["BYTECODE"] = "this.activeBytecode";
+    NullaryOperator["INPUT_COUNT"] = "tx.inputs.length";
+    NullaryOperator["OUTPUT_COUNT"] = "tx.outputs.length";
+    NullaryOperator["VERSION"] = "tx.version";
+    NullaryOperator["LOCKTIME"] = "tx.locktime";
+})(NullaryOperator = exports.NullaryOperator || (exports.NullaryOperator = {}));
 var UnaryOperator;
 (function (UnaryOperator) {
     UnaryOperator["NOT"] = "!";
     UnaryOperator["NEGATE"] = "-";
     UnaryOperator["SIZE"] = ".length";
     UnaryOperator["REVERSE"] = ".reverse()";
+    UnaryOperator["INPUT_VALUE"] = "tx.inputs[i].value";
+    UnaryOperator["INPUT_LOCKING_BYTECODE"] = "tx.inputs[i].lockingBytecode";
+    UnaryOperator["INPUT_OUTPOINT_HASH"] = "tx.inputs[i].outpointTransactionHash";
+    UnaryOperator["INPUT_OUTPOINT_INDEX"] = "tx.inputs[i].outpointIndex";
+    UnaryOperator["INPUT_UNLOCKING_BYTECODE"] = "tx.inputs[i].unlockingBytecode";
+    UnaryOperator["INPUT_SEQUENCE_NUMBER"] = "tx.inputs[i].sequenceNumber";
+    UnaryOperator["OUTPUT_VALUE"] = "tx.outputs[i].value";
+    UnaryOperator["OUTPUT_LOCKING_BYTECODE"] = "tx.outputs[i].lockingBytecode";
 })(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
 var BinaryOperator;
 (function (BinaryOperator) {
+    BinaryOperator["MUL"] = "*";
     BinaryOperator["DIV"] = "/";
     BinaryOperator["MOD"] = "%";
     BinaryOperator["PLUS"] = "+";

package/dist/main/cashc-cli.js

@@ -20,6 +20,7 @@ commander_1.program
     .option('-A, --asm', 'Compile the contract to ASM format rather than a full artifact.')
     .option('-c, --opcount', 'Display the number of opcodes in the compiled bytecode.')
     .option('-s, --size', 'Display the size in bytes of the compiled bytecode.')
+    .helpOption('-?, --help', 'Display help')
     .parse();
 const opts = commander_1.program.opts();
 run();

package/dist/main/compiler.js

@@ -16,7 +16,6 @@ const CashScriptParser_1 = require("./grammar/CashScriptParser");
 const SymbolTableTraversal_1 = __importDefault(require("./semantic/SymbolTableTraversal"));
 const TypeCheckTraversal_1 = __importDefault(require("./semantic/TypeCheckTraversal"));
 const EnsureFinalRequireTraversal_1 = __importDefault(require("./semantic/EnsureFinalRequireTraversal"));
-const VerifyCovenantTraversal_1 = __importDefault(require("./semantic/VerifyCovenantTraversal"));
 function compileString(code) {
     // Lexing + parsing
     let ast = parseCode(code);
@@ -24,7 +23,6 @@ function compileString(code) {
     ast = ast.accept(new SymbolTableTraversal_1.default());
     ast = ast.accept(new TypeCheckTraversal_1.default());
     ast = ast.accept(new EnsureFinalRequireTraversal_1.default());
-    ast = ast.accept(new VerifyCovenantTraversal_1.default());
     // Code generation
     const traversal = new GenerateTargetTraversal_1.default();
     ast = ast.accept(traversal);

package/dist/main/generation/GenerateTargetTraversal.d.ts

@@ -1,14 +1,11 @@
 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 } from '../ast/AST';
+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';
 import AstTraversal from '../ast/AstTraversal';
-import { PreimageField } from '../ast/Globals';
 export default class GenerateTargetTraversal extends AstTraversal {
     output: Script;
     stack: string[];
     private scopeDepth;
     private currentFunction;
-    private isCheckSigVerify;
-    private covenantNeedsToBeVerified;
     private emit;
     private pushToStack;
     private popFromStack;
@@ -18,27 +15,25 @@ export default class GenerateTargetTraversal extends AstTraversal {
     visitSourceFile(node: SourceFileNode): Node;
     visitContract(node: ContractNode): Node;
     visitFunctionDefinition(node: FunctionDefinitionNode): Node;
-    decodePreimage(fields: PreimageField[]): void;
     removeFinalVerify(): void;
     cleanStack(): void;
     visitParameter(node: ParameterNode): Node;
     visitVariableDefinition(node: VariableDefinitionNode): Node;
+    visitTupleAssignment(node: TupleAssignmentNode): Node;
     visitAssign(node: AssignNode): Node;
     emitReplace(index: number): void;
     visitTimeOp(node: TimeOpNode): Node;
     visitRequire(node: RequireNode): Node;
-    containsCheckSig(node: RequireNode): boolean;
     visitBranch(node: BranchNode): Node;
     removeScopedVariables(depthBeforeScope: number): void;
     visitCast(node: CastNode): Node;
     visitFunctionCall(node: FunctionCallNode): Node;
     visitMultiSig(node: FunctionCallNode): Node;
-    needsToVerifyCovenant(node: FunctionCallNode): boolean;
-    verifyCovenant(): void;
     visitInstantiation(node: InstantiationNode): Node;
     visitTupleIndexOp(node: TupleIndexOpNode): Node;
     visitBinaryOp(node: BinaryOpNode): Node;
     visitUnaryOp(node: UnaryOpNode): Node;
+    visitNullaryOp(node: NullaryOpNode): Node;
     visitArray(node: ArrayNode): Node;
     visitIdentifier(node: IdentifierNode): Node;
     isOpRoll(node: IdentifierNode): boolean;