skittles 0.1.1 → 0.1.2

package/lib/compiler.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTypeScriptToBytecode = void 0;
+const get_bytecode_1 = __importDefault(require("./get-bytecode"));
+const get_skittles_class_1 = __importDefault(require("./get-skittles-class"));
+const get_yul_1 = __importDefault(require("./get-yul"));
+const compileTypeScriptToBytecode = (fileName) => __awaiter(void 0, void 0, void 0, function* () {
+    const skittlesClass = (0, get_skittles_class_1.default)(fileName);
+    const yul = (0, get_yul_1.default)(fileName);
+    return (0, get_bytecode_1.default)(skittlesClass.name, yul);
+});
+exports.compileTypeScriptToBytecode = compileTypeScriptToBytecode;

package/lib/data/yul-template.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YulSection = void 0;
+var YulSection;
+(function (YulSection) {
+    YulSection["Dispatchers"] = "dispatchers";
+    YulSection["Functions"] = "functions";
+    YulSection["StorageLayout"] = "storage layout";
+    YulSection["StorageAccess"] = "storage access";
+})(YulSection = exports.YulSection || (exports.YulSection = {}));
+const yulTemplate = [
+    `    code {`,
+    `        // Deploy the contract`,
+    `        datacopy(0, dataoffset("runtime"), datasize("runtime"))`,
+    `        return(0, datasize("runtime"))`,
+    `    }`,
+    `    object "runtime" {`,
+    `        code {`,
+    `            switch selector()`,
+    `            /* ---------- dispatchers ----------- */`,
+    `            default {`,
+    `                revert(0, 0)`,
+    `            }`,
+    ``,
+    ``,
+    `            /* ---------- functions ----------- */`,
+    ``,
+    ``,
+    `            /* ---------- calldata decoding functions ----------- */`,
+    `            function selector() -> s {`,
+    `                s := div(calldataload(0), 0x100000000000000000000000000000000000000000000000000000000)`,
+    `            }`,
+    `            function decodeAsAddress(offset) -> v {`,
+    `                v := decodeAsUint(offset)`,
+    `                if iszero(iszero(and(v, not(0xffffffffffffffffffffffffffffffffffffffff)))) {`,
+    `                    revert(0, 0)`,
+    `                }`,
+    `            }`,
+    `            function decodeAsUint(offset) -> v {`,
+    `                let pos := add(4, mul(offset, 0x20))`,
+    `                if lt(calldatasize(), add(pos, 0x20)) {`,
+    `                    revert(0, 0)`,
+    `                }`,
+    `                v := calldataload(pos)`,
+    `            }`,
+    ``,
+    ``,
+    `            /* ---------- calldata encoding functions ---------- */`,
+    `            function returnUint(v) {`,
+    `                mstore(0, v)`,
+    `                return(0, 0x20)`,
+    `            }`,
+    `            function returnTrue() {`,
+    `                returnUint(1)`,
+    `            }`,
+    ``,
+    ``,
+    `            /* -------- storage layout ---------- */`,
+    ``,
+    ``,
+    `            /* -------- storage access ---------- */`,
+    ``,
+    ``,
+    `            /* ---------- utility functions start ---------- */`,
+    `            function lte(a, b) -> r {`,
+    `                r := iszero(gt(a, b))`,
+    `            }`,
+    `            function gte(a, b) -> r {`,
+    `                r := iszero(lt(a, b))`,
+    `            }`,
+    `            function safeAdd(a, b) -> r {`,
+    `                r := add(a, b)`,
+    `                if or(lt(r, a), lt(r, b)) { revert(0, 0) }`,
+    `            }`,
+    `            function revertIfZeroAddress(addr) {`,
+    `                require(addr)`,
+    `            }`,
+    `            function require(condition) {`,
+    `                if iszero(condition) { revert(0, 0) }`,
+    `            }`,
+    `        }`,
+    `    }`,
+    `}`,
+];
+exports.default = yulTemplate;

package/lib/get-abi.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPropertyAbi = (property) => {
+    return {
+        type: "function",
+        name: property.name,
+        inputs: [],
+        outputs: [{ name: "", type: property.type }],
+        stateMutability: "view",
+    };
+};
+const getMethodAbi = (method) => {
+    return {
+        type: "function",
+        name: method.name,
+        inputs: method.parameters.map((i) => ({
+            name: i.name,
+            type: i.type,
+        })),
+        outputs: [{ name: "", type: method.returns }],
+        stateMutability: method.view ? "view" : "payable",
+    };
+};
+const getAbi = (skittlesClass) => {
+    return [
+        ...skittlesClass.properties.filter((p) => !p.private).map(getPropertyAbi),
+        ...skittlesClass.methods.filter((p) => !p.private).map(getMethodAbi),
+    ];
+};
+exports.default = getAbi;

package/lib/get-ast.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = require("typescript");
+const getAst = (file) => {
+    let program = (0, typescript_1.createProgram)([file], {
+        allowJs: true,
+        target: typescript_1.ScriptTarget.ES5,
+        module: typescript_1.ModuleKind.CommonJS,
+    });
+    const ast = program.getSourceFile(file);
+    if (!ast)
+        throw new Error("Could not get AST");
+    return ast;
+};
+exports.default = getAst;

package/lib/get-bytecode.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const solc = require("solc");
+const getBytecode = (className, content) => {
+    const input = {
+        language: "Yul",
+        sources: {
+            main: {
+                content,
+            },
+        },
+        settings: {
+            outputSelection: {
+                "*": {
+                    "*": ["*"],
+                },
+            },
+        },
+    };
+    const compiled = JSON.parse(solc.compile(JSON.stringify(input)));
+    return compiled.contracts["main"][className].evm.bytecode.object;
+};
+exports.default = getBytecode;

package/lib/get-selector.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const exampleValues = {
+    uint256: 1,
+    bool: true,
+    string: "hello",
+    address: "0x1234567890123456789012345678901234567890",
+};
+const getSelector = (abi, func) => {
+    const iface = new ethers_1.utils.Interface(abi);
+    const abiFunction = abi.find((f) => f.name === func);
+    if (!abiFunction)
+        throw new Error(`Could not find function ${func}`);
+    const params = abiFunction.inputs.map((input) => exampleValues[input.type]);
+    const data = iface.encodeFunctionData(func, params);
+    return data.substring(0, 10);
+};
+exports.default = getSelector;

package/lib/get-skittles-class.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSkittlesParameters = void 0;
+const typescript_1 = require("typescript");
+const get_ast_1 = __importDefault(require("./get-ast"));
+const ast_helper_1 = require("./helpers/ast-helper");
+const skittles_class_1 = require("./types/skittles-class");
+const getSkittlesType = (syntaxKind) => {
+    if (!syntaxKind)
+        return "void";
+    switch (syntaxKind) {
+        case typescript_1.SyntaxKind.StringKeyword:
+            return "string";
+        case typescript_1.SyntaxKind.NumberKeyword:
+            return "uint256";
+        case typescript_1.SyntaxKind.BooleanKeyword:
+            return "boolean";
+        case typescript_1.SyntaxKind.VoidKeyword:
+            return "void";
+        case typescript_1.SyntaxKind.AnyKeyword:
+            return "any";
+        default:
+            throw new Error(`Unknown syntax kind: ${syntaxKind}`);
+    }
+};
+const getSkittlesOperator = (syntaxKind) => {
+    switch (syntaxKind) {
+        case typescript_1.SyntaxKind.PlusToken:
+            return skittles_class_1.SkittlesOperator.Plus;
+        case typescript_1.SyntaxKind.MinusToken:
+            return skittles_class_1.SkittlesOperator.Minus;
+        case typescript_1.SyntaxKind.AsteriskToken:
+            return skittles_class_1.SkittlesOperator.Multiply;
+        case typescript_1.SyntaxKind.SlashToken:
+            return skittles_class_1.SkittlesOperator.Divide;
+        case typescript_1.SyntaxKind.PercentToken:
+            return skittles_class_1.SkittlesOperator.Modulo;
+        case typescript_1.SyntaxKind.AmpersandAmpersandToken:
+            return skittles_class_1.SkittlesOperator.And;
+        case typescript_1.SyntaxKind.BarBarToken:
+            return skittles_class_1.SkittlesOperator.Or;
+        case typescript_1.SyntaxKind.EqualsEqualsToken:
+            return skittles_class_1.SkittlesOperator.Equals;
+        case typescript_1.SyntaxKind.ExclamationEqualsToken:
+            return skittles_class_1.SkittlesOperator.NotEquals;
+        case typescript_1.SyntaxKind.LessThanToken:
+            return skittles_class_1.SkittlesOperator.LessThan;
+        case typescript_1.SyntaxKind.LessThanEqualsToken:
+            return skittles_class_1.SkittlesOperator.LessThanOrEqual;
+        case typescript_1.SyntaxKind.GreaterThanToken:
+            return skittles_class_1.SkittlesOperator.GreaterThan;
+        case typescript_1.SyntaxKind.GreaterThanEqualsToken:
+            return skittles_class_1.SkittlesOperator.GreaterThanOrEqual;
+        default:
+            throw new Error(`Unknown syntax kind: ${syntaxKind}`);
+    }
+};
+const getSkittlesExpression = (expression) => {
+    if ((0, typescript_1.isLiteralExpression)(expression)) {
+        return {
+            expressionType: skittles_class_1.SkittlesExpressionType.Value,
+            value: expression.text,
+        };
+    }
+    if ((0, typescript_1.isIdentifier)(expression)) {
+        return {
+            expressionType: skittles_class_1.SkittlesExpressionType.Value,
+            value: expression.escapedText,
+        };
+    }
+    if ((0, typescript_1.isPropertyAccessExpression)(expression)) {
+        return {
+            expressionType: skittles_class_1.SkittlesExpressionType.Storage,
+            variable: (0, ast_helper_1.getNodeName)(expression),
+        };
+    }
+    if ((0, typescript_1.isBinaryExpression)(expression)) {
+        return {
+            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+            left: getSkittlesExpression(expression.left),
+            right: getSkittlesExpression(expression.right),
+            operator: getSkittlesOperator(expression.operatorToken.kind),
+        };
+    }
+    throw new Error(`Unknown expression type: ${expression.kind}`);
+};
+const isNodePrivate = (node) => {
+    let isPrivate = false;
+    (0, typescript_1.forEachChild)(node, (node) => {
+        if (node.kind === typescript_1.SyntaxKind.PrivateKeyword) {
+            isPrivate = true;
+        }
+    });
+    return isPrivate;
+};
+const getSkittlesProperty = (astProperty) => {
+    if (!astProperty.type)
+        throw new Error("Could not get property type");
+    const initializer = astProperty.initializer;
+    return {
+        name: (0, ast_helper_1.getNodeName)(astProperty),
+        type: getSkittlesType(astProperty.type.kind),
+        value: initializer ? getSkittlesExpression(initializer) : undefined,
+        private: isNodePrivate(astProperty),
+    };
+};
+const isNodeView = (node) => {
+    let isView = true;
+    (0, typescript_1.forEachChild)(node, (child) => {
+        if ((0, typescript_1.isBinaryExpression)(child)) {
+            if ((0, typescript_1.isPropertyAccessExpression)(child.left)) {
+                if ((0, ast_helper_1.isPlusEquals)(child) || (0, ast_helper_1.isEquals)(child) || (0, ast_helper_1.isMinusEquals)(child)) {
+                    isView = false;
+                }
+            }
+        }
+        if (!isNodeView(child)) {
+            isView = false;
+        }
+    });
+    return isView;
+};
+const getSkittlesParameters = (node) => {
+    const inputs = [];
+    (0, typescript_1.forEachChild)(node, (node) => {
+        var _a;
+        if ((0, typescript_1.isParameter)(node)) {
+            inputs.push({
+                name: (0, ast_helper_1.getNodeName)(node),
+                type: getSkittlesType((_a = node.type) === null || _a === void 0 ? void 0 : _a.kind),
+            });
+        }
+    });
+    return inputs;
+};
+exports.getSkittlesParameters = getSkittlesParameters;
+const getSkittlesStatement = (node, returnType) => {
+    if ((0, typescript_1.isExpressionStatement)(node)) {
+        const expression = node.expression;
+        if ((0, typescript_1.isBinaryExpression)(expression)) {
+            if ((0, typescript_1.isPropertyAccessExpression)(expression.left)) {
+                if ((0, ast_helper_1.isEquals)(expression)) {
+                    return {
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: getSkittlesExpression(expression.right),
+                    };
+                }
+                if ((0, ast_helper_1.isPlusEquals)(expression)) {
+                    return {
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: {
+                            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+                            operator: skittles_class_1.SkittlesOperator.Plus,
+                            left: getSkittlesExpression(expression.left),
+                            right: getSkittlesExpression(expression.right),
+                        },
+                    };
+                }
+                if ((0, ast_helper_1.isMinusEquals)(expression)) {
+                    return {
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: {
+                            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+                            operator: skittles_class_1.SkittlesOperator.Minus,
+                            left: getSkittlesExpression(expression.left),
+                            right: getSkittlesExpression(expression.right),
+                        },
+                    };
+                }
+                throw new Error(`Unknown binary expression: ${expression.operatorToken.kind}`);
+            }
+            throw new Error(`Unknown binary expression type: ${expression.kind}`);
+        }
+        throw new Error("Not implemented expression statement handling");
+    }
+    if ((0, typescript_1.isReturnStatement)(node)) {
+        const expression = node.expression;
+        if (!expression)
+            throw new Error("Return statement has no expression");
+        if ((0, typescript_1.isBinaryExpression)(expression)) {
+            return {
+                statementType: skittles_class_1.SkittlesStatementType.Return,
+                type: returnType,
+                value: getSkittlesExpression(node.expression),
+            };
+        }
+    }
+    throw new Error(`Unknown statement type: ${node.kind}`);
+};
+const getSkittlesMethod = (astMethod) => {
+    var _a, _b;
+    return {
+        name: (0, ast_helper_1.getNodeName)(astMethod),
+        returns: getSkittlesType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind),
+        private: isNodePrivate(astMethod),
+        view: isNodeView(astMethod),
+        parameters: (0, exports.getSkittlesParameters)(astMethod),
+        statements: ((_b = astMethod.body) === null || _b === void 0 ? void 0 : _b.statements.map((statement) => { var _a; return getSkittlesStatement(statement, getSkittlesType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind)); })) || [],
+    };
+};
+const getSkittlesClass = (file) => {
+    const ast = (0, get_ast_1.default)(file);
+    const classNode = (0, ast_helper_1.getClassNode)(ast);
+    const astProperties = classNode.members.filter(typescript_1.isPropertyDeclaration);
+    const astMethods = classNode.members.filter(typescript_1.isMethodDeclaration);
+    return {
+        name: (0, ast_helper_1.getNodeName)(classNode),
+        properties: astProperties.map(getSkittlesProperty),
+        methods: astMethods.map(getSkittlesMethod),
+    };
+};
+exports.default = getSkittlesClass;

package/lib/get-yul.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yul_template_1 = __importStar(require("./data/yul-template"));
+const get_abi_1 = __importDefault(require("./get-abi"));
+const get_selector_1 = __importDefault(require("./get-selector"));
+const get_skittles_class_1 = __importDefault(require("./get-skittles-class"));
+const skittles_class_1 = require("./types/skittles-class");
+const addToSection = (yul, section, lines) => {
+    const sectionIndex = yul.findIndex((line) => line.includes(`- ${section} -`));
+    if (sectionIndex === -1) {
+        yul.push(`${section}:`);
+        yul.push(...lines);
+    }
+    else {
+        yul.splice(sectionIndex + 1, 0, ...lines);
+    }
+    return yul;
+};
+const decoderFunctions = {
+    address: "decodeAsAddress",
+    uint256: "decodeAsUint",
+};
+const returnFunctions = {
+    uint256: "returnUint",
+    boolean: "returnTrue",
+};
+const getBaseYul = (name) => {
+    const base = yul_template_1.default;
+    base.unshift(`object "${name}" {`);
+    return base;
+};
+const addPropertyDispatcher = (yul, abi, property) => {
+    const { name, type } = property;
+    const selector = (0, get_selector_1.default)(abi, name);
+    return addToSection(yul, yul_template_1.YulSection.Dispatchers, [
+        `            case ${selector} /* "${name}()" */ {`,
+        `                ${returnFunctions[type]}(${name}Storage())`,
+        `            }`,
+    ]);
+};
+const addMethodDispatcher = (yul, abi, method) => {
+    const { name, parameters, returns } = method;
+    const selector = (0, get_selector_1.default)(abi, name);
+    return addToSection(yul, yul_template_1.YulSection.Dispatchers, [
+        `            case ${selector} /* "${name}(${parameters
+            .map((p) => p.type)
+            .join(",")})" */ {`,
+        returns === "void"
+            ? `                ${name}Function(${parameters
+                .map((input, index) => `${decoderFunctions[input.type]}(${index})`)
+                .join(", ")})`
+            : `                ${returnFunctions[returns]}(${name}Function())`,
+        `            }`,
+    ]);
+};
+const getBinaryYul = (expression) => {
+    const { left, right, operator } = expression;
+    switch (operator) {
+        case skittles_class_1.SkittlesOperator.Plus:
+            return `safeAdd(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Minus:
+            return `sub(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Multiply:
+            return `mul(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Divide:
+            return `div(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Modulo:
+            return `mod(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Equals:
+            return `eq(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.NotEquals:
+            return `not(eq(${getExpressionYul(left)}, ${getExpressionYul(right)}))`;
+        case skittles_class_1.SkittlesOperator.GreaterThan:
+            return `gt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.LessThan:
+            return `lt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.GreaterThanOrEqual:
+            return `gte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.LessThanOrEqual:
+            return `lte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.And:
+            return `and(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Or:
+            return `or(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case skittles_class_1.SkittlesOperator.Not:
+            return `not(${getExpressionYul(left)})`;
+        default:
+            throw new Error(`Unsupported binary operator ${operator}`);
+    }
+};
+const getExpressionYul = (expression) => {
+    switch (expression.expressionType) {
+        case skittles_class_1.SkittlesExpressionType.Binary:
+            return getBinaryYul(expression);
+        case skittles_class_1.SkittlesExpressionType.Value:
+            return expression.value;
+        case skittles_class_1.SkittlesExpressionType.Storage:
+            return `${expression.variable}Storage()`;
+        default:
+            throw new Error("Unsupported expression");
+    }
+};
+const getStorageUpdateYul = (statement) => {
+    const { variable, value } = statement;
+    return `                ${variable}Set(${getExpressionYul(value)})`;
+};
+const getReturnYul = (statement) => {
+    const { value } = statement;
+    return `                v := ${getExpressionYul(value)}`;
+};
+const getStatementYul = (statement) => {
+    switch (statement.statementType) {
+        case skittles_class_1.SkittlesStatementType.StorageUpdate:
+            return getStorageUpdateYul(statement);
+        case skittles_class_1.SkittlesStatementType.Return:
+            return getReturnYul(statement);
+        default:
+            throw new Error("Unsupported statement");
+    }
+};
+const getBlockYul = (statements) => {
+    return statements.map((statement) => getStatementYul(statement));
+};
+const addMethodFunction = (yul, method) => {
+    const { name, parameters, returns, statements } = method;
+    const hasReturn = returns !== "void";
+    return addToSection(yul, yul_template_1.YulSection.Functions, [
+        `            function ${name}Function(${parameters
+            .map((input) => input.name)
+            .join(", ")}) ${hasReturn ? `-> v ` : ""}{`,
+        ...getBlockYul(statements),
+        `            }`,
+    ]);
+};
+const addStorageLayout = (yul, property, index) => {
+    const { name } = property;
+    return addToSection(yul, yul_template_1.YulSection.StorageLayout, [
+        `            function ${name}Pos() -> p { p := ${index} }`,
+    ]);
+};
+const addStorageAccess = (yul, property) => {
+    const { name } = property;
+    const initial = name.substring(0, 1);
+    return addToSection(yul, yul_template_1.YulSection.StorageAccess, [
+        `            function ${name}Storage() -> ${initial} {`,
+        `                ${initial} := sload(${name}Pos())`,
+        `            }`,
+        `            function ${name}Set(value) {`,
+        `                sstore(${name}Pos(), value)`,
+        `            }`,
+    ]);
+};
+const getYul = (file) => {
+    // Getting base data
+    const skittlesClass = (0, get_skittles_class_1.default)(file);
+    const abi = (0, get_abi_1.default)(skittlesClass);
+    let yul = getBaseYul(skittlesClass.name);
+    // Adding properties
+    skittlesClass.properties.forEach((property, index) => {
+        yul = addPropertyDispatcher(yul, abi, property);
+        yul = addStorageLayout(yul, property, index);
+        yul = addStorageAccess(yul, property);
+        // TODO Handle private properties
+    });
+    // Adding methods
+    skittlesClass.methods.forEach((method) => {
+        yul = addMethodDispatcher(yul, abi, method);
+        yul = addMethodFunction(yul, method);
+        // TODO Handle private methods
+    });
+    // forEachChild(ast, process);
+    return yul.join("\n");
+};
+exports.default = getYul;

package/lib/helpers/ast-helper.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMinusEquals = exports.isEquals = exports.isPlusEquals = exports.getNodeReturnType = exports.getNodeName = exports.getClassNode = void 0;
+const typescript_1 = require("typescript");
+const getClassNode = (node) => {
+    if ((0, typescript_1.isClassDeclaration)(node)) {
+        return node;
+    }
+    let classNode = undefined;
+    (0, typescript_1.forEachChild)(node, (child) => {
+        if ((0, typescript_1.isClassDeclaration)(child)) {
+            classNode = child;
+        }
+    });
+    if (!classNode)
+        throw new Error("Could not find class");
+    return classNode;
+};
+exports.getClassNode = getClassNode;
+const getNodeName = (node) => {
+    if (node.text)
+        return node.text;
+    if (node.escapedText)
+        return node.escapedText;
+    return node.name.escapedText;
+};
+exports.getNodeName = getNodeName;
+const getNodeReturnType = (node) => {
+    const type = node.type;
+    if (!type)
+        return "void";
+    if (type.kind === typescript_1.SyntaxKind.NumberKeyword) {
+        return "uint256";
+    }
+    if (type.kind === typescript_1.SyntaxKind.VoidKeyword) {
+        return "void";
+    }
+    // TODO Add more types
+    throw new Error("Unsupported type");
+};
+exports.getNodeReturnType = getNodeReturnType;
+const isPlusEquals = (expression) => {
+    return expression.operatorToken.kind === typescript_1.SyntaxKind.PlusEqualsToken;
+};
+exports.isPlusEquals = isPlusEquals;
+const isEquals = (expression) => {
+    return expression.operatorToken.kind === typescript_1.SyntaxKind.EqualsToken;
+};
+exports.isEquals = isEquals;
+const isMinusEquals = (expression) => {
+    return expression.operatorToken.kind === typescript_1.SyntaxKind.MinusEqualsToken;
+};
+exports.isMinusEquals = isMinusEquals;

package/lib/helpers/file-helper.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllContractFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const CONTRCT_PATH = "./contracts";
+const getAllContractFiles = () => {
+    return fs_1.default
+        .readdirSync(CONTRCT_PATH)
+        .filter((file) => {
+        return fs_1.default.statSync(path_1.default.join(CONTRCT_PATH, file)).isFile();
+    })
+        .map((file) => {
+        return path_1.default.join(CONTRCT_PATH, file);
+    })
+        .filter((file) => {
+        return file.endsWith(".ts") || file.endsWith(".js");
+    });
+};
+exports.getAllContractFiles = getAllContractFiles;

package/lib/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const compiler_1 = require("./compiler");
+const file_helper_1 = require("./helpers/file-helper");
+// clear();
+// console.log(
+//   chalk.red(figlet.textSync("skittles-cli", { horizontalLayout: "full" }))
+// );
+commander_1.program
+    .name("skittles")
+    .description("CLI for the Skittles compiler")
+    .version("0.1.0");
+// program
+//   .command("compile")
+//   .description("Compile TypeScript file")
+//   .argument("<string>", "file name")
+//   .action(async (str, options) => {
+//     console.log(await compileTypeScriptToBytecode(str));
+//   });
+commander_1.program
+    .command("compile")
+    .description("Compile all TypeScript file")
+    .action((str, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const files = (0, file_helper_1.getAllContractFiles)();
+    const promises = files.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log(yield (0, compiler_1.compileTypeScriptToBytecode)(file));
+    }));
+    yield Promise.all(promises);
+}));
+commander_1.program.parse();

package/lib/types/skittles-class.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkittlesStatementType = exports.SkittlesOperator = exports.SkittlesExpressionType = void 0;
+var SkittlesExpressionType;
+(function (SkittlesExpressionType) {
+    SkittlesExpressionType["Binary"] = "Binary";
+    SkittlesExpressionType["Value"] = "Value";
+    SkittlesExpressionType["Storage"] = "Storage";
+})(SkittlesExpressionType = exports.SkittlesExpressionType || (exports.SkittlesExpressionType = {}));
+var SkittlesOperator;
+(function (SkittlesOperator) {
+    SkittlesOperator["Plus"] = "+";
+    SkittlesOperator["Minus"] = "-";
+    SkittlesOperator["Multiply"] = "*";
+    SkittlesOperator["Divide"] = "/";
+    SkittlesOperator["Modulo"] = "%";
+    SkittlesOperator["Equals"] = "==";
+    SkittlesOperator["NotEquals"] = "!=";
+    SkittlesOperator["GreaterThan"] = ">";
+    SkittlesOperator["LessThan"] = "<";
+    SkittlesOperator["GreaterThanOrEqual"] = ">=";
+    SkittlesOperator["LessThanOrEqual"] = "<=";
+    SkittlesOperator["And"] = "&&";
+    SkittlesOperator["Or"] = "||";
+    SkittlesOperator["Not"] = "!";
+})(SkittlesOperator = exports.SkittlesOperator || (exports.SkittlesOperator = {}));
+var SkittlesStatementType;
+(function (SkittlesStatementType) {
+    SkittlesStatementType["StorageUpdate"] = "StorageUpdate";
+    SkittlesStatementType["Return"] = "Return";
+})(SkittlesStatementType = exports.SkittlesStatementType || (exports.SkittlesStatementType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skittles",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript Smart Contract Language for the EVM",
   "main": "./lib/index.js",
   "bin": {