skittles 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+Make it a cli app
+Create and deploy package
+save artifacts/build
+Remove tabs in yul, surely this can be automated or somethign
+Use the `FoxOperator` strings for the assemby stuff
+Try changing balance to 1 in the contract and run tests
+add prepublish
+
+Add more support
+remove Token.yul
+
+add readme
+
+Add other normal repo things

package/hardhat.config.ts

@@ -0,0 +1,29 @@
+import * as dotenv from "dotenv";
+
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomiclabs/hardhat-etherscan";
+import "@nomiclabs/hardhat-waffle";
+import "@typechain/hardhat";
+import "hardhat-gas-reporter";
+
+dotenv.config();
+
+const config: HardhatUserConfig = {
+  solidity: "0.8.4",
+  networks: {
+    ropsten: {
+      url: process.env.ROPSTEN_URL || "",
+      accounts:
+        process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
+    },
+  },
+  gasReporter: {
+    enabled: process.env.REPORT_GAS !== undefined,
+    currency: "USD",
+  },
+  etherscan: {
+    apiKey: process.env.ETHERSCAN_API_KEY,
+  },
+};
+
+export default config;

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_fox_class_1 = __importDefault(require("./get-fox-class"));
+const get_yul_1 = __importDefault(require("./get-yul"));
+const compileTypeScriptToBytecode = (fileName) => __awaiter(void 0, void 0, void 0, function* () {
+    const foxClass = (0, get_fox_class_1.default)(fileName);
+    const yul = (0, get_yul_1.default)(fileName);
+    return (0, get_bytecode_1.default)(foxClass.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 = (foxClass) => {
+    return [
+        ...foxClass.properties.filter((p) => !p.private).map(getPropertyAbi),
+        ...foxClass.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-fox-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.getFoxParameters = void 0;
+const typescript_1 = require("typescript");
+const get_ast_1 = __importDefault(require("./get-ast"));
+const ast_helper_1 = require("./helpers/ast-helper");
+const fox_class_1 = require("./types/fox-class");
+const getFoxType = (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 getFoxOperator = (syntaxKind) => {
+    switch (syntaxKind) {
+        case typescript_1.SyntaxKind.PlusToken:
+            return fox_class_1.FoxOperator.Plus;
+        case typescript_1.SyntaxKind.MinusToken:
+            return fox_class_1.FoxOperator.Minus;
+        case typescript_1.SyntaxKind.AsteriskToken:
+            return fox_class_1.FoxOperator.Multiply;
+        case typescript_1.SyntaxKind.SlashToken:
+            return fox_class_1.FoxOperator.Divide;
+        case typescript_1.SyntaxKind.PercentToken:
+            return fox_class_1.FoxOperator.Modulo;
+        case typescript_1.SyntaxKind.AmpersandAmpersandToken:
+            return fox_class_1.FoxOperator.And;
+        case typescript_1.SyntaxKind.BarBarToken:
+            return fox_class_1.FoxOperator.Or;
+        case typescript_1.SyntaxKind.EqualsEqualsToken:
+            return fox_class_1.FoxOperator.Equals;
+        case typescript_1.SyntaxKind.ExclamationEqualsToken:
+            return fox_class_1.FoxOperator.NotEquals;
+        case typescript_1.SyntaxKind.LessThanToken:
+            return fox_class_1.FoxOperator.LessThan;
+        case typescript_1.SyntaxKind.LessThanEqualsToken:
+            return fox_class_1.FoxOperator.LessThanOrEqual;
+        case typescript_1.SyntaxKind.GreaterThanToken:
+            return fox_class_1.FoxOperator.GreaterThan;
+        case typescript_1.SyntaxKind.GreaterThanEqualsToken:
+            return fox_class_1.FoxOperator.GreaterThanOrEqual;
+        default:
+            throw new Error(`Unknown syntax kind: ${syntaxKind}`);
+    }
+};
+const getFoxExpression = (expression) => {
+    if ((0, typescript_1.isLiteralExpression)(expression)) {
+        return {
+            expressionType: fox_class_1.FoxExpressionType.Value,
+            value: expression.text,
+        };
+    }
+    if ((0, typescript_1.isIdentifier)(expression)) {
+        return {
+            expressionType: fox_class_1.FoxExpressionType.Value,
+            value: expression.escapedText,
+        };
+    }
+    if ((0, typescript_1.isPropertyAccessExpression)(expression)) {
+        return {
+            expressionType: fox_class_1.FoxExpressionType.Storage,
+            variable: (0, ast_helper_1.getNodeName)(expression),
+        };
+    }
+    if ((0, typescript_1.isBinaryExpression)(expression)) {
+        return {
+            expressionType: fox_class_1.FoxExpressionType.Binary,
+            left: getFoxExpression(expression.left),
+            right: getFoxExpression(expression.right),
+            operator: getFoxOperator(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 getFoxProperty = (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: getFoxType(astProperty.type.kind),
+        value: initializer ? getFoxExpression(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 getFoxParameters = (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: getFoxType((_a = node.type) === null || _a === void 0 ? void 0 : _a.kind),
+            });
+        }
+    });
+    return inputs;
+};
+exports.getFoxParameters = getFoxParameters;
+const getFoxStatement = (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: fox_class_1.FoxStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: getFoxExpression(expression.right),
+                    };
+                }
+                if ((0, ast_helper_1.isPlusEquals)(expression)) {
+                    return {
+                        statementType: fox_class_1.FoxStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: {
+                            expressionType: fox_class_1.FoxExpressionType.Binary,
+                            operator: fox_class_1.FoxOperator.Plus,
+                            left: getFoxExpression(expression.left),
+                            right: getFoxExpression(expression.right),
+                        },
+                    };
+                }
+                if ((0, ast_helper_1.isMinusEquals)(expression)) {
+                    return {
+                        statementType: fox_class_1.FoxStatementType.StorageUpdate,
+                        variable: (0, ast_helper_1.getNodeName)(expression.left),
+                        value: {
+                            expressionType: fox_class_1.FoxExpressionType.Binary,
+                            operator: fox_class_1.FoxOperator.Minus,
+                            left: getFoxExpression(expression.left),
+                            right: getFoxExpression(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: fox_class_1.FoxStatementType.Return,
+                type: returnType,
+                value: getFoxExpression(node.expression),
+            };
+        }
+    }
+    throw new Error(`Unknown statement type: ${node.kind}`);
+};
+const getFoxMethod = (astMethod) => {
+    var _a, _b;
+    return {
+        name: (0, ast_helper_1.getNodeName)(astMethod),
+        returns: getFoxType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind),
+        private: isNodePrivate(astMethod),
+        view: isNodeView(astMethod),
+        parameters: (0, exports.getFoxParameters)(astMethod),
+        statements: ((_b = astMethod.body) === null || _b === void 0 ? void 0 : _b.statements.map((statement) => { var _a; return getFoxStatement(statement, getFoxType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind)); })) || [],
+    };
+};
+const getFoxClass = (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(getFoxProperty),
+        methods: astMethods.map(getFoxMethod),
+    };
+};
+exports.default = getFoxClass;

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-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_fox_class_1 = __importDefault(require("./get-fox-class"));
+const fox_class_1 = require("./types/fox-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 fox_class_1.FoxOperator.Plus:
+            return `safeAdd(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Minus:
+            return `sub(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Multiply:
+            return `mul(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Divide:
+            return `div(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Modulo:
+            return `mod(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Equals:
+            return `eq(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.NotEquals:
+            return `not(eq(${getExpressionYul(left)}, ${getExpressionYul(right)}))`;
+        case fox_class_1.FoxOperator.GreaterThan:
+            return `gt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.LessThan:
+            return `lt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.GreaterThanOrEqual:
+            return `gte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.LessThanOrEqual:
+            return `lte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.And:
+            return `and(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Or:
+            return `or(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
+        case fox_class_1.FoxOperator.Not:
+            return `not(${getExpressionYul(left)})`;
+        default:
+            throw new Error(`Unsupported binary operator ${operator}`);
+    }
+};
+const getExpressionYul = (expression) => {
+    switch (expression.expressionType) {
+        case fox_class_1.FoxExpressionType.Binary:
+            return getBinaryYul(expression);
+        case fox_class_1.FoxExpressionType.Value:
+            return expression.value;
+        case fox_class_1.FoxExpressionType.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 fox_class_1.FoxStatementType.StorageUpdate:
+            return getStorageUpdateYul(statement);
+        case fox_class_1.FoxStatementType.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 foxClass = (0, get_fox_class_1.default)(file);
+    const abi = (0, get_abi_1.default)(foxClass);
+    let yul = getBaseYul(foxClass.name);
+    // Adding properties
+    foxClass.properties.forEach((property, index) => {
+        yul = addPropertyDispatcher(yul, abi, property);
+        yul = addStorageLayout(yul, property, index);
+        yul = addStorageAccess(yul, property);
+        // TODO Handle private properties
+    });
+    // Adding methods
+    foxClass.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,38 @@
+#!/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("fox-cli", { horizontalLayout: "full" }))
+// );
+commander_1.program.name("fox").description("CLI for the Fox 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/fox-class.js

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

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "skittles",
+  "version": "0.1.0",
+  "description": "TypeScript Smart Contract Language for the EVM",
+  "main": "./lib/index.js",
+  "bin": {
+    "fox": "./lib/index.js"
+  },
+  "scripts": {
+    "start": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts",
+    "create": "yarn run build && yarn run test",
+    "build": "tsc -p .",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && yarn",
+    "local": "sudo yarn global add && fox",
+    "test": "hardhat test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chase-manning/fox.git"
+  },
+  "author": "Chase Manning",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/chase-manning/fox/issues"
+  },
+  "homepage": "https://github.com/chase-manning/fox#readme",
+  "dependencies": {
+    "chalk": "4.1.2",
+    "clear": "^0.1.0",
+    "commander": "^9.4.0",
+    "figlet": "^1.5.2",
+    "path": "^0.12.7",
+    "solc": "^0.8.16",
+    "typescript": "^4.7.4"
+  },
+  "devDependencies": {
+    "@nomiclabs/hardhat-ethers": "^2.1.0",
+    "@nomiclabs/hardhat-etherscan": "^3.1.0",
+    "@nomiclabs/hardhat-waffle": "^2.0.3",
+    "@typechain/ethers-v5": "^7.2.0",
+    "@typechain/hardhat": "^2.3.1",
+    "@types/chai": "^4.3.1",
+    "@types/clear": "^0.1.2",
+    "@types/figlet": "^1.5.4",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.6.4",
+    "@typescript-eslint/eslint-plugin": "^4.33.0",
+    "@typescript-eslint/parser": "^4.33.0",
+    "chai": "^4.3.6",
+    "dotenv": "^16.0.1",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.4.1",
+    "eslint-plugin-promise": "^5.2.0",
+    "ethereum-waffle": "^3.4.4",
+    "ethers": "^5.6.9",
+    "hardhat": "^2.10.1",
+    "hardhat-gas-reporter": "^1.0.8",
+    "nodemon": "^2.0.19",
+    "prettier": "^2.7.1",
+    "prettier-plugin-solidity": "^1.0.0-beta.13",
+    "solhint": "^3.3.7",
+    "solidity-coverage": "^0.7.21",
+    "ts-node": "^10.9.1",
+    "typechain": "^5.2.0"
+  }
+}