4 files changed, 173 insertions, 0 deletions
diff --git a/packages/abi-gen/src/globals.d.ts b/packages/abi-gen/src/globals.d.ts
new file mode 100644
index 000000000..39df3f852
--- /dev/null
+++ b/packages/abi-gen/src/globals.d.ts
@@ -0,0 +1,4 @@
+declare function toSnakeCase(str: string): string;
+declare module 'to-snake-case' {
+    export = toSnakeCase;
+}
diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts
new file mode 100644
index 000000000..19d289e49
--- /dev/null
+++ b/packages/abi-gen/src/index.ts
@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import * as fs from 'fs';
+import {sync as globSync} from 'glob';
+import * as Handlebars from 'handlebars';
+import * as _ from 'lodash';
+import * as mkdirp from 'mkdirp';
+import * as yargs from 'yargs';
+
+import toSnakeCase = require('to-snake-case');
+import * as Web3 from 'web3';
+
+import {ContextData, ParamKind} from './types';
+import {utils} from './utils';
+
+const ABI_TYPE_METHOD = 'function';
+const MAIN_TEMPLATE_NAME = 'contract.mustache';
+
+const args = yargs
+    .option('abiGlob', {
+        describe: 'Glob pattern to search for ABI JSON files',
+        type: 'string',
+        demand: true,
+    })
+    .option('templates', {
+        describe: 'Folder where to search for templates',
+        type: 'string',
+        demand: true,
+    })
+    .option('output', {
+        describe: 'Folder where to put the output files',
+        type: 'string',
+        demand: true,
+    })
+    .argv;
+
+function writeOutputFile(name: string, renderedTsCode: string): void {
+    const fileName = toSnakeCase(name);
+    const filePath = `${args.output}/${fileName}.ts`;
+    fs.writeFileSync(filePath, renderedTsCode);
+    utils.log(`Created: ${chalk.bold(filePath)}`);
+}
+
+Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input));
+Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output));
+const partialTemplateFileNames = globSync(`${args.templates}/partials/**/*.mustache`);
+for (const partialTemplateFileName of partialTemplateFileNames) {
+    const namedContent = utils.getNamedContent(partialTemplateFileName);
+    Handlebars.registerPartial(namedContent.name, namedContent.content);
+}
+
+const mainTemplate = utils.getNamedContent(`${args.templates}/${MAIN_TEMPLATE_NAME}`);
+const template = Handlebars.compile<ContextData>(mainTemplate.content);
+const abiFileNames = globSync(args.abiGlob);
+if (_.isEmpty(abiFileNames)) {
+    utils.log(`${chalk.red(`No ABI files found.`)}`);
+    utils.log(`Please make sure you've passed the correct folder name and that the files have
+               ${chalk.bold('*.json')} extensions`);
+    process.exit(1);
+} else {
+    utils.log(`Found ${chalk.green(`${abiFileNames.length}`)} ${chalk.bold('ABI')} files`);
+    mkdirp.sync(args.output);
+}
+for (const abiFileName of abiFileNames) {
+    const namedContent = utils.getNamedContent(abiFileName);
+    utils.log(`Processing: ${chalk.bold(namedContent.name)}...`);
+    const parsedContent = JSON.parse(namedContent.content);
+    const ABI = _.isArray(parsedContent) ?
+                parsedContent : // ABI file
+                parsedContent.abi; // Truffle contracts file
+    if (_.isUndefined(ABI)) {
+        utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
+        utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`);
+        process.exit(1);
+    }
+    const methodAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_METHOD) as Web3.MethodAbi[];
+    const methodsData = _.map(methodAbis, methodAbi => {
+        _.map(methodAbi.inputs, input => {
+            if (_.isEmpty(input.name)) {
+                // Auto-generated getters don't have parameter names
+                input.name = 'index';
+            }
+        });
+        // This will make templates simpler
+        const methodData = {
+            ...methodAbi,
+            singleReturnValue: methodAbi.outputs.length === 1,
+        };
+        return methodData;
+    });
+    const contextData = {
+        contractName: namedContent.name,
+        methods: methodsData,
+    };
+    const renderedTsCode = template(contextData);
+    writeOutputFile(namedContent.name, renderedTsCode);
+}
diff --git a/packages/abi-gen/src/types.ts b/packages/abi-gen/src/types.ts
new file mode 100644
index 000000000..1dc039c83
--- /dev/null
+++ b/packages/abi-gen/src/types.ts
@@ -0,0 +1,15 @@
+import * as Web3 from 'web3';
+
+export enum ParamKind {
+    Input = 'input',
+    Output = 'output',
+}
+
+export interface Method extends Web3.MethodAbi {
+    singleReturnValue: boolean;
+}
+
+export interface ContextData {
+    contractName: string;
+    methods: Method[];
+}
diff --git a/packages/abi-gen/src/utils.ts b/packages/abi-gen/src/utils.ts
new file mode 100644
index 000000000..eaf5a30cc
--- /dev/null
+++ b/packages/abi-gen/src/utils.ts
@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import * as _ from 'lodash';
+import * as path from 'path';
+
+import {ParamKind} from './types';
+
+export const utils = {
+    solTypeToTsType(paramKind: ParamKind, solType: string): string {
+        const trailingArrayRegex = /\[\d*\]$/;
+        if (solType.match(trailingArrayRegex)) {
+            const arrayItemSolType = solType.replace(trailingArrayRegex, '');
+            const arrayItemTsType = utils.solTypeToTsType(paramKind, arrayItemSolType);
+            const arrayTsType = `${arrayItemTsType}[]`;
+            return arrayTsType;
+        } else {
+            const solTypeRegexToTsType = [
+                {regex: '^string$', tsType: 'string'},
+                {regex: '^address$', tsType: 'string'},
+                {regex: '^bool$', tsType: 'boolean'},
+                {regex: '^u?int\\d*$', tsType: 'BigNumber'},
+                {regex: '^bytes\\d*$', tsType: 'string'},
+            ];
+            if (paramKind === ParamKind.Input) {
+                // web3 allows to pass those an non-bignumbers and that's nice
+                // but it always returns stuff as BigNumbers
+                solTypeRegexToTsType.unshift({regex: '^u?int(8|16|32)?$', tsType: 'number|BigNumber'});
+            }
+            for (const regexAndTxType of solTypeRegexToTsType) {
+                const {regex, tsType} = regexAndTxType;
+                if (solType.match(regex)) {
+                    return tsType;
+                }
+            }
+            throw new Error(`Unknown Solidity type found: ${solType}`);
+        }
+    },
+    log(...args: any[]): void {
+        console.log(...args); // tslint:disable-line:no-console
+    },
+    getPartialNameFromFileName(filename: string): string {
+        const name = path.parse(filename).name;
+        return name;
+    },
+    getNamedContent(filename: string): {name: string; content: string} {
+        const name = utils.getPartialNameFromFileName(filename);
+        try {
+            const content = fs.readFileSync(filename).toString();
+            return {
+                name,
+                content,
+            };
+        } catch (err) {
+            throw new Error(`Failed to read ${filename}: ${err}`);
+        }
+    },
+};