skittles 0.2.0 → 0.3.0

package/lib/abi/get-abi.js

@@ -1,37 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const skittles_class_1 = require("../types/skittles-class");
+const getTypeString = (type) => {
+    return type.kind;
+};
 const getConstructorAbi = (constructor) => {
     if (!constructor)
         return [];
     return [
         {
             type: "constructor",
-            inputs: constructor.parameters.map((i) => ({
-                name: i.name,
-                type: i.type,
-            })),
+            inputs: constructor.parameters.map((i) => {
+                return {
+                    name: i.name,
+                    type: getTypeString(i.type),
+                };
+            }),
             stateMutability: "nonpayable",
         },
     ];
 };
 const getPropertyAbi = (property) => {
+    if (property.type.kind === skittles_class_1.SkittlesTypeKind.Mapping) {
+        return {
+            type: "function",
+            name: property.name,
+            inputs: property.type.inputs.map((i) => {
+                return {
+                    name: "",
+                    type: getTypeString(i),
+                };
+            }),
+            outputs: [{ name: "", type: getTypeString(property.type.output) }],
+            stateMutability: "view",
+        };
+    }
+    if (property.type.kind === skittles_class_1.SkittlesTypeKind.Array) {
+        return {
+            type: "function",
+            name: property.name,
+            inputs: [
+                {
+                    name: "index",
+                    type: "uint256",
+                },
+            ],
+            outputs: [{ name: "", type: getTypeString(property.type.itemType) }],
+            stateMutability: "view",
+        };
+    }
     return {
         type: "function",
         name: property.name,
         inputs: [],
-        outputs: [{ name: "", type: property.type }],
+        outputs: [{ name: "", type: getTypeString(property.type) }],
         stateMutability: "view",
     };
 };
 const getMethodAbi = (method) => {
+    const outputs = () => {
+        const { returns } = method;
+        if (returns.kind === skittles_class_1.SkittlesTypeKind.Void)
+            return [];
+        if (returns.kind === skittles_class_1.SkittlesTypeKind.Interface) {
+            return [
+                ...returns.interface.elements.map((e) => {
+                    return {
+                        name: e.name,
+                        type: getTypeString(e.type),
+                    };
+                }),
+            ];
+        }
+        return [
+            {
+                name: "",
+                type: getTypeString(returns),
+            },
+        ];
+    };
     return {
         type: "function",
         name: method.name,
-        inputs: method.parameters.map((i) => ({
-            name: i.name,
-            type: i.type,
-        })),
-        outputs: [{ name: "", type: method.returns }],
+        inputs: method.parameters.map((i) => {
+            return {
+                name: i.name,
+                type: getTypeString(i.type),
+            };
+        }),
+        outputs: outputs(),
         stateMutability: method.view ? "view" : "payable",
     };
 };

package/lib/compiler/skittles-compiler.d.ts

@@ -0,0 +1,2 @@
+declare const skittlesCompile: () => void;
+export default skittlesCompile;

package/lib/compiler/skittles-compiler.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ora_1 = __importDefault(require("ora"));
+const get_abi_1 = __importDefault(require("../abi/get-abi"));
+const get_bytecode_1 = __importDefault(require("../bytecode/get-bytecode"));
+const add_dependencies_1 = __importDefault(require("../dependencies/add-dependencies"));
+const file_helper_1 = require("../helpers/file-helper");
+const get_skittles_class_1 = __importDefault(require("../skittles-class/get-skittles-class"));
+const get_yul_1 = __importDefault(require("../yul/get-yul"));
+const doTask = (task, fn) => {
+    const spinner = (0, ora_1.default)(task).start();
+    const response = fn();
+    spinner.succeed();
+    return response;
+};
+const skittlesCompile = () => {
+    const files = doTask("Loading Contracts", () => (0, file_helper_1.getAllContractFiles)());
+    const classes = doTask("Processing", () => files.map(get_skittles_class_1.default));
+    classes.forEach((skittlesClass) => {
+        const { name } = skittlesClass;
+        doTask(`Compiling ${name}`, () => {
+            const newClass = (0, add_dependencies_1.default)(skittlesClass, classes);
+            const abi = (0, get_abi_1.default)(newClass);
+            (0, file_helper_1.writeFile)("abi", name, JSON.stringify(abi, null, 2));
+            const yul = (0, get_yul_1.default)(newClass, abi);
+            (0, file_helper_1.writeFile)("yul", name, yul);
+            const bytecode = (0, get_bytecode_1.default)(name, yul);
+            (0, file_helper_1.writeFile)("bytecode", name, bytecode);
+        });
+    });
+};
+exports.default = skittlesCompile;

package/lib/data/constants.d.ts

@@ -0,0 +1 @@
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

package/lib/data/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZERO_ADDRESS = void 0;
+exports.ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

package/lib/data/yul-template.d.ts

@@ -2,6 +2,7 @@ export declare enum YulSection {
     Constructor = "constructor",
     Dispatchers = "dispatchers",
     Functions = "functions",
+    ConstructorFunctions = "constructor functions",
     StorageLayout = "storage layout",
     ConstructorStorageLayout = "constructor storage layout",
     StorageAccess = "storage access",

package/lib/data/yul-template.js

@@ -6,6 +6,7 @@ var YulSection;
     YulSection["Constructor"] = "constructor";
     YulSection["Dispatchers"] = "dispatchers";
     YulSection["Functions"] = "functions";
+    YulSection["ConstructorFunctions"] = "constructor functions";
     YulSection["StorageLayout"] = "storage layout";
     YulSection["ConstructorStorageLayout"] = "constructor storage layout";
     YulSection["StorageAccess"] = "storage access";
@@ -54,6 +55,9 @@ const yulTemplate = [
     `/* ---------- constructor ----------- */`,
     ``,
     ``,
+    `/* ---------- constructor functions ----------- */`,
+    ``,
+    ``,
     `/* -------- constructor storage layout ---------- */`,
     ``,
     ``,
@@ -108,6 +112,9 @@ const yulTemplate = [
     `mstore(64, v)`,
     `return(0x00, 0x60)`,
     `}`,
+    `function returnArray(v) {`,
+    `return(0, v)`,
+    `}`,
     `function returnBoolean(v) {`,
     `switch v`,
     `case true {`,

package/lib/dependencies/add-dependencies.d.ts

@@ -0,0 +1,3 @@
+import SkittlesClass from "../types/skittles-class";
+declare const addDependencies: (skittlesClass: SkittlesClass, classes: SkittlesClass[]) => SkittlesClass;
+export default addDependencies;

package/lib/dependencies/add-dependencies.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addDependencies = (skittlesClass, classes) => {
+    const dependencyClasses = classes.filter((c) => {
+        return skittlesClass.classExtensions.includes(c.name);
+    });
+    if (dependencyClasses.length === 0)
+        return skittlesClass;
+    const { name, constructor, methods, interfaces, variables, classExtensions } = skittlesClass;
+    dependencyClasses.forEach((dependencyClass) => {
+        const { methods: dependencyMethods, interfaces: dependencyInterfaces, variables: dependencyVariables, classExtensions: dependencyClassExtensions, } = dependencyClass;
+        Object.entries(dependencyInterfaces).forEach(([key, value]) => {
+            if (!interfaces[key])
+                interfaces[key] = value;
+        });
+        methods.push(...dependencyMethods);
+        variables.push(...dependencyVariables);
+        classExtensions.push(...dependencyClassExtensions);
+    });
+    return {
+        classExtensions,
+        name,
+        constructor,
+        methods,
+        interfaces,
+        variables,
+    };
+};
+exports.default = addDependencies;

package/lib/helpers/ast-helper.js

@@ -48,7 +48,8 @@ exports.isFalseKeyword = isFalseKeyword;
 const isNodePrivate = (node) => {
     let isPrivate = false;
     (0, typescript_1.forEachChild)(node, (node) => {
-        if (node.kind === typescript_1.SyntaxKind.PrivateKeyword) {
+        if (node.kind === typescript_1.SyntaxKind.PrivateKeyword ||
+            node.kind === typescript_1.SyntaxKind.ProtectedKeyword) {
             isPrivate = true;
         }
     });

package/lib/helpers/file-helper.d.ts

@@ -1,3 +1,4 @@
+export declare const getAllFilesInDirectory: (dir: string) => string[];
 export declare const getAllContractFiles: () => string[];
 export declare const writeFile: (type: string, fileName: string, content: string) => void;
 export declare const clearDirectory: (directory: string) => void;

package/lib/helpers/file-helper.js

@@ -3,21 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractName = exports.clearDirectory = exports.writeFile = exports.getAllContractFiles = void 0;
+exports.getContractName = exports.clearDirectory = exports.writeFile = exports.getAllContractFiles = exports.getAllFilesInDirectory = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const CONTRCT_PATH = "./contracts";
+const getAllFilesInDirectory = (dir) => {
+    const files = [];
+    fs_1.default.readdirSync(dir).forEach((file) => {
+        const filePath = path_1.default.join(dir, file);
+        if (fs_1.default.statSync(filePath).isDirectory()) {
+            files.push(...(0, exports.getAllFilesInDirectory)(filePath));
+        }
+        else {
+            files.push(filePath);
+        }
+    });
+    return files;
+};
+exports.getAllFilesInDirectory = getAllFilesInDirectory;
 const getAllContractFiles = () => {
-    return fs_1.default
-        .readdirSync(CONTRCT_PATH)
+    return (0, exports.getAllFilesInDirectory)(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);
+        return fs_1.default.statSync(file).isFile();
     })
         .filter((file) => {
-        return file.endsWith(".ts") || file.endsWith(".js");
+        return (file.endsWith(".ts") &&
+            !file.endsWith(".d.ts") &&
+            !file.endsWith(".spec.ts"));
     });
 };
 exports.getAllContractFiles = getAllContractFiles;

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 import { address, self, block, chain, msg, tx } from "./types/core-types";
 import getSkittlesFactory from "./testing/get-skittles-factory";
-export { address, self, block, chain, msg, tx, getSkittlesFactory };
+import { ZERO_ADDRESS } from "./data/constants";
+export { address, self, block, chain, msg, tx, getSkittlesFactory, ZERO_ADDRESS, };

package/lib/index.js

@@ -13,13 +13,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSkittlesFactory = exports.tx = exports.msg = exports.chain = exports.block = exports.self = void 0;
+exports.ZERO_ADDRESS = exports.getSkittlesFactory = exports.tx = exports.msg = exports.chain = exports.block = exports.self = void 0;
 const yargs_1 = __importDefault(require("yargs"));
-const get_abi_1 = __importDefault(require("./abi/get-abi"));
-const get_bytecode_1 = __importDefault(require("./bytecode/get-bytecode"));
 const file_helper_1 = require("./helpers/file-helper");
-const get_skittles_class_1 = __importDefault(require("./skittles-class/get-skittles-class"));
-const get_yul_1 = __importDefault(require("./yul/get-yul"));
 const core_types_1 = require("./types/core-types");
 Object.defineProperty(exports, "self", { enumerable: true, get: function () { return core_types_1.self; } });
 Object.defineProperty(exports, "block", { enumerable: true, get: function () { return core_types_1.block; } });
@@ -29,28 +25,13 @@ Object.defineProperty(exports, "tx", { enumerable: true, get: function () { retu
 const get_skittles_factory_1 = __importDefault(require("./testing/get-skittles-factory"));
 exports.getSkittlesFactory = get_skittles_factory_1.default;
 const console_helper_1 = require("./helpers/console-helper");
-const ora_1 = __importDefault(require("ora"));
-const skittlesCompile = () => {
-    const filesSpinner = (0, ora_1.default)("Loading Contracts").start();
-    const files = (0, file_helper_1.getAllContractFiles)();
-    filesSpinner.succeed();
-    files.forEach((file) => {
-        const name = (0, file_helper_1.getContractName)(file);
-        const spinner = (0, ora_1.default)(`Compiling ${name}`).start();
-        const skittlesClass = (0, get_skittles_class_1.default)(file);
-        const abi = (0, get_abi_1.default)(skittlesClass);
-        (0, file_helper_1.writeFile)("abi", name, JSON.stringify(abi, null, 2));
-        const yul = (0, get_yul_1.default)(skittlesClass, abi);
-        (0, file_helper_1.writeFile)("yul", name, yul);
-        const bytecode = (0, get_bytecode_1.default)(name, yul);
-        (0, file_helper_1.writeFile)("bytecode", name, bytecode);
-        spinner.succeed();
-    });
-};
+const skittles_compiler_1 = __importDefault(require("./compiler/skittles-compiler"));
+const constants_1 = require("./data/constants");
+Object.defineProperty(exports, "ZERO_ADDRESS", { enumerable: true, get: function () { return constants_1.ZERO_ADDRESS; } });
 yargs_1.default
     .command("compile", "Compile all TypeScript files", () => __awaiter(void 0, void 0, void 0, function* () {
     (0, console_helper_1.logSkittles)();
-    skittlesCompile();
+    (0, skittles_compiler_1.default)();
 }))
     .command("clean", "Clears the cache and deletes all builds", () => {
     (0, file_helper_1.clearDirectory)("./build");

package/lib/skittles-class/get-skittles-class.js

@@ -7,12 +7,14 @@ const typescript_1 = require("typescript");
 const get_ast_1 = __importDefault(require("../ast/get-ast"));
 const ast_helper_1 = require("../helpers/ast-helper");
 const get_skittles_constructor_1 = __importDefault(require("./get-skittles-constructor"));
+const get_skittles_interfaces_1 = __importDefault(require("./get-skittles-interfaces"));
 const get_skittles_method_1 = __importDefault(require("./get-skittles-method"));
 const get_skittles_property_1 = __importDefault(require("./get-skittles-property"));
 const get_skittles_state_mutability_1 = __importDefault(require("./get-skittles-state-mutability"));
 const getSkittlesClass = (file) => {
     const ast = (0, get_ast_1.default)(file);
     const classNode = (0, ast_helper_1.getClassNode)(ast);
+    const interfaces = (0, get_skittles_interfaces_1.default)(ast);
     const astVariables = classNode.members
         .filter(typescript_1.isPropertyDeclaration)
         .filter(ast_helper_1.isVariable);
@@ -21,15 +23,26 @@ const getSkittlesClass = (file) => {
         .filter(typescript_1.isPropertyDeclaration)
         .filter(ast_helper_1.isPropertyArrowFunction);
     const astConstructor = classNode.members.find(typescript_1.isConstructorDeclaration);
+    const classExtensions = [];
+    const { heritageClauses } = classNode;
+    if (heritageClauses) {
+        heritageClauses.forEach((heritageClause) => {
+            heritageClause.types.forEach((type) => {
+                classExtensions.push((0, ast_helper_1.getNodeName)(type.expression));
+            });
+        });
+    }
     const skittlesClass = {
+        classExtensions,
+        interfaces,
         name: (0, ast_helper_1.getNodeName)(classNode),
         constructor: astConstructor
-            ? (0, get_skittles_constructor_1.default)(astConstructor)
+            ? (0, get_skittles_constructor_1.default)(astConstructor, interfaces)
             : undefined,
-        variables: astVariables.map(get_skittles_property_1.default),
+        variables: astVariables.map((v) => (0, get_skittles_property_1.default)(v, interfaces)),
         methods: [
-            ...astMethods.map(get_skittles_method_1.default),
-            ...astArrowFunctions.map(get_skittles_method_1.default),
+            ...astMethods.map((m) => (0, get_skittles_method_1.default)(m, interfaces)),
+            ...astArrowFunctions.map((f) => (0, get_skittles_method_1.default)(f, interfaces)),
         ],
     };
     return (0, get_skittles_state_mutability_1.default)(skittlesClass);

package/lib/skittles-class/get-skittles-constructor.d.ts

@@ -1,4 +1,4 @@
 import { ConstructorDeclaration } from "typescript";
-import { SkittlesConstructor } from "../types/skittles-class";
-declare const getSkittlesConstructor: (astConstructor: ConstructorDeclaration) => SkittlesConstructor;
+import { SkittlesConstructor, SkittlesInterfaces } from "../types/skittles-class";
+declare const getSkittlesConstructor: (astConstructor: ConstructorDeclaration, interfaces: SkittlesInterfaces) => SkittlesConstructor;
 export default getSkittlesConstructor;

package/lib/skittles-class/get-skittles-constructor.js

@@ -6,15 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ast_helper_1 = require("../helpers/ast-helper");
 const get_skittles_statements_1 = __importDefault(require("./get-skittles-statements"));
 const get_skittles_type_1 = __importDefault(require("./get-skittles-type"));
-const getSkittlesConstructor = (astConstructor) => {
+const getSkittlesConstructor = (astConstructor, interfaces) => {
     return {
         parameters: astConstructor.parameters.map((parameter) => {
             return {
                 name: (0, ast_helper_1.getNodeName)(parameter),
-                type: (0, get_skittles_type_1.default)(parameter.type),
+                type: (0, get_skittles_type_1.default)(parameter.type, interfaces),
             };
         }),
-        statements: (0, get_skittles_statements_1.default)(astConstructor.body, (0, get_skittles_type_1.default)(astConstructor.type)),
+        statements: (0, get_skittles_statements_1.default)(astConstructor.body, (0, get_skittles_type_1.default)(astConstructor.type, interfaces), interfaces),
     };
 };
 exports.default = getSkittlesConstructor;

package/lib/skittles-class/get-skittles-expression.d.ts

@@ -1,4 +1,4 @@
 import { Expression } from "typescript";
-import { SkittlesExpression } from "../types/skittles-class";
-declare const getSkittlesExpression: (expression: Expression) => SkittlesExpression;
+import { SkittlesExpression, SkittlesInterfaces } from "../types/skittles-class";
+declare const getSkittlesExpression: (expression: Expression, interfaces: SkittlesInterfaces) => SkittlesExpression;
 export default getSkittlesExpression;

package/lib/skittles-class/get-skittles-expression.js

@@ -8,87 +8,148 @@ const ast_helper_1 = require("../helpers/ast-helper");
 const skittles_class_1 = require("../types/skittles-class");
 const get_skittles_operator_1 = __importDefault(require("./get-skittles-operator"));
 const get_skittles_type_1 = __importDefault(require("./get-skittles-type"));
-const getSkittlesExpression = (expression) => {
-    if ((0, typescript_1.isIdentifier)(expression)) {
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Variable,
-            value: expression.escapedText,
-        };
+const getIdentifierExpression = (expression) => {
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Variable,
+        value: expression.escapedText,
+    };
+};
+const getLiteralExpression = (expression, interfaces) => {
+    const value = expression.text;
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Value,
+        type: (0, get_skittles_type_1.default)(expression, interfaces, value),
+        value,
+    };
+};
+const getPropertyAccessExpression = (expression, interfaces) => {
+    if (expression.expression.kind === typescript_1.SyntaxKind.PropertyAccessExpression) {
+        const property = (0, ast_helper_1.getNodeName)(expression);
+        switch (property) {
+            case "length":
+                return {
+                    expressionType: skittles_class_1.SkittlesExpressionType.Length,
+                    value: getSkittlesExpression(expression.expression, interfaces),
+                };
+            default:
+                throw new Error(`Unknown property access property: ${property}`);
+        }
     }
-    if ((0, typescript_1.isLiteralExpression)(expression)) {
-        const value = expression.text;
+    if (expression.expression.kind === typescript_1.SyntaxKind.ThisKeyword) {
         return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Value,
-            type: (0, get_skittles_type_1.default)(expression, value),
-            value,
+            expressionType: skittles_class_1.SkittlesExpressionType.Storage,
+            variable: (0, ast_helper_1.getNodeName)(expression),
         };
     }
-    if ((0, typescript_1.isPropertyAccessExpression)(expression)) {
-        if (expression.expression.kind === typescript_1.SyntaxKind.ThisKeyword) {
+    if (expression.expression.kind === typescript_1.SyntaxKind.Identifier) {
+        const environment = expression.expression.escapedText;
+        if (!environment)
+            throw new Error("Could not get environment");
+        if (["block", "chain", "msg", "tx"].includes(environment)) {
             return {
-                expressionType: skittles_class_1.SkittlesExpressionType.Storage,
+                expressionType: skittles_class_1.SkittlesExpressionType.EvmDialect,
+                environment: environment,
                 variable: (0, ast_helper_1.getNodeName)(expression),
             };
         }
-        if (expression.expression.kind === typescript_1.SyntaxKind.Identifier) {
-            const environment = expression.expression.escapedText;
-            if (!environment)
-                throw new Error("Could not get environment");
-            if (["block", "chain", "msg", "tx"].includes(environment)) {
+        if (environment === "Number") {
+            const element = (0, ast_helper_1.getNodeName)(expression.name);
+            if (element === "MAX_SAFE_INTEGER" || element === "MAX_VALUE") {
                 return {
-                    expressionType: skittles_class_1.SkittlesExpressionType.EvmDialect,
-                    environment: environment,
-                    variable: (0, ast_helper_1.getNodeName)(expression),
+                    expressionType: skittles_class_1.SkittlesExpressionType.Value,
+                    type: {
+                        kind: skittles_class_1.SkittlesTypeKind.Number,
+                    },
+                    value: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
                 };
             }
-            throw new Error(`Unknown environment: ${environment}`);
+            throw new Error(`Could not get value for ${element}`);
         }
-        throw new Error(`Property access expression not supported ${expression.getText()}`);
+        throw new Error(`Unknown environment: ${environment}`);
+    }
+    throw new Error(`Property access expression not supported ${expression.kind}`);
+};
+const getBinaryExpression = (expression, interfaces) => {
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+        left: getSkittlesExpression(expression.left, interfaces),
+        right: getSkittlesExpression(expression.right, interfaces),
+        operator: (0, get_skittles_operator_1.default)(expression.operatorToken.kind),
+    };
+};
+const getElementAccessExpression = (expression, interfaces) => {
+    let e = expression;
+    const items = [];
+    while ((0, typescript_1.isElementAccessExpression)(e)) {
+        items.unshift(getSkittlesExpression(e.argumentExpression, interfaces));
+        e = e.expression;
+    }
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Mapping,
+        variable: (0, ast_helper_1.getNodeName)(e),
+        items,
+    };
+};
+const getPrefixUnaryExpression = (expression, interfaces) => {
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Not,
+        value: getSkittlesExpression(expression.operand, interfaces),
+    };
+};
+const getBooleanExpression = (item) => {
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Value,
+        type: { kind: skittles_class_1.SkittlesTypeKind.Void },
+        value: item ? "true" : "false",
+    };
+};
+const getThisExpression = () => {
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.This,
+    };
+};
+const getNewExpression = (expression, interfaces) => {
+    var _a;
+    return {
+        expressionType: skittles_class_1.SkittlesExpressionType.Deploy,
+        contract: (0, ast_helper_1.getNodeName)(expression.expression),
+        parameters: ((_a = expression.arguments) === null || _a === void 0 ? void 0 : _a.map((arg) => getSkittlesExpression(arg, interfaces))) || [],
+    };
+};
+const getSkittlesExpression = (expression, interfaces) => {
+    if ((0, typescript_1.isIdentifier)(expression)) {
+        return getIdentifierExpression(expression);
+    }
+    if ((0, typescript_1.isLiteralExpression)(expression)) {
+        return getLiteralExpression(expression, interfaces);
+    }
+    if ((0, typescript_1.isPropertyAccessExpression)(expression)) {
+        return getPropertyAccessExpression(expression, interfaces);
     }
     if ((0, typescript_1.isBinaryExpression)(expression)) {
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
-            left: getSkittlesExpression(expression.left),
-            right: getSkittlesExpression(expression.right),
-            operator: (0, get_skittles_operator_1.default)(expression.operatorToken.kind),
-        };
+        return getBinaryExpression(expression, interfaces);
     }
     if ((0, typescript_1.isElementAccessExpression)(expression)) {
-        const items = [];
-        while ((0, typescript_1.isElementAccessExpression)(expression)) {
-            items.unshift(getSkittlesExpression(expression.argumentExpression));
-            expression = expression.expression;
-        }
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Mapping,
-            variable: (0, ast_helper_1.getNodeName)(expression),
-            items,
-        };
+        return getElementAccessExpression(expression, interfaces);
     }
     if ((0, typescript_1.isParenthesizedExpression)(expression)) {
-        return getSkittlesExpression(expression.expression);
+        return getSkittlesExpression(expression.expression, interfaces);
     }
     if ((0, typescript_1.isPrefixUnaryExpression)(expression)) {
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Not,
-            value: getSkittlesExpression(expression.operand),
-        };
+        return getPrefixUnaryExpression(expression, interfaces);
     }
     if ((0, ast_helper_1.isTrueKeyword)(expression)) {
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Value,
-            type: "bool",
-            value: "true",
-        };
+        return getBooleanExpression(true);
     }
     if ((0, ast_helper_1.isFalseKeyword)(expression)) {
-        return {
-            expressionType: skittles_class_1.SkittlesExpressionType.Value,
-            type: "bool",
-            value: "false",
-        };
+        return getBooleanExpression(false);
+    }
+    if (expression.kind === typescript_1.SyntaxKind.ThisKeyword) {
+        return getThisExpression();
+    }
+    if ((0, typescript_1.isNewExpression)(expression)) {
+        return getNewExpression(expression, interfaces);
     }
-    console.log(JSON.stringify(expression));
     throw new Error(`Unknown expression type: ${expression.kind}`);
 };
 exports.default = getSkittlesExpression;

package/lib/skittles-class/get-skittles-interfaces.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "typescript";
+import { SkittlesInterfaces } from "../types/skittles-class";
+declare const getSkittlesInterfaces: (node: Node) => SkittlesInterfaces;
+export default getSkittlesInterfaces;