Merge branch 'development' into breakUp0xjs

* development:
  Fix ganache subprovider config
  Fix a bug in compiler config precedence
  Fix linter errors
  Fix templates
  Remove unused deployer docs configs
  Add a legacy endpoint for the deployer
  Add a check for compiler output
  Add a comment
  Put ARTIFACTS_VERSION in a config
  Improve a comment
  Remove _applyDefaultsToDeployTxDataAsync
  Add a HACK comment
  Fix linter issues
  Rename deployer to sol-compiler
  Remove deployer
  Remove deployer from 0x.js and migrations
  Configure migrations with a compiler.json
  Remove deployer from metacoin and contract tests
  Update wallet footer and add remove token functionality

# Conflicts:
#	.gitignore
#	packages/0x.js/package.json
#	packages/0x.js/src/0x.ts
#	packages/contracts/package.json
#	packages/contracts/test/multi_sig_with_time_lock.ts
#	packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts
#	packages/contracts/util/artifacts.ts
#	packages/deployer/test/deployer_test.ts
#	packages/migrations/package.json

13 files changed, 594 insertions, 0 deletions

diff --git a/packages/sol-compiler/src/cli.ts b/packages/sol-compiler/src/cli.ts
new file mode 100644
index 000000000..71bb80c7d
--- /dev/null
+++ b/packages/sol-compiler/src/cli.ts
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// We need the above pragma since this script will be run as a command-line tool.
+
+import { BigNumber, logUtils } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+import * as path from 'path';
+import * as Web3 from 'web3';
+import * as yargs from 'yargs';
+
+import { Compiler } from './compiler';
+import { constants } from './utils/constants';
+import { CompilerOptions } from './utils/types';
+
+const DEFAULT_CONTRACTS_LIST = '*';
+const SEPARATOR = ',';
+
+(async () => {
+    const argv = yargs
+        .option('contracts-dir', {
+            type: 'string',
+            description: 'path of contracts directory to compile',
+        })
+        .option('artifacts-dir', {
+            type: 'string',
+            description: 'path to write contracts artifacts to',
+        })
+        .option('contracts', {
+            type: 'string',
+            description: 'comma separated list of contracts to compile',
+        })
+        .help().argv;
+    const contracts = _.isUndefined(argv.contracts)
+        ? undefined
+        : argv.contracts === DEFAULT_CONTRACTS_LIST ? DEFAULT_CONTRACTS_LIST : argv.contracts.split(SEPARATOR);
+    const opts: CompilerOptions = {
+        contractsDir: argv.contractsDir,
+        artifactsDir: argv.artifactsDir,
+        contracts,
+    };
+    const compiler = new Compiler(opts);
+    await compiler.compileAsync();
+})().catch(err => {
+    logUtils.log(err);
+    process.exit(1);
+});
diff --git a/packages/sol-compiler/src/compiler.ts b/packages/sol-compiler/src/compiler.ts
new file mode 100644
index 000000000..efb30091b
--- /dev/null
+++ b/packages/sol-compiler/src/compiler.ts
@@ -0,0 +1,276 @@
+import {
+    ContractSource,
+    ContractSources,
+    EnumerableResolver,
+    FallthroughResolver,
+    FSResolver,
+    NameResolver,
+    NPMResolver,
+    RelativeFSResolver,
+    Resolver,
+    URLResolver,
+} from '@0xproject/sol-resolver';
+import { ContractAbi } from '@0xproject/types';
+import { logUtils, promisify } from '@0xproject/utils';
+import chalk from 'chalk';
+import * as ethUtil from 'ethereumjs-util';
+import * as fs from 'fs';
+import 'isomorphic-fetch';
+import * as _ from 'lodash';
+import * as path from 'path';
+import * as requireFromString from 'require-from-string';
+import * as semver from 'semver';
+import solc = require('solc');
+
+import { binPaths } from './solc/bin_paths';
+import {
+    createDirIfDoesNotExistAsync,
+    getContractArtifactIfExistsAsync,
+    getNormalizedErrMsg,
+    parseDependencies,
+    parseSolidityVersionRange,
+} from './utils/compiler';
+import { constants } from './utils/constants';
+import { fsWrapper } from './utils/fs_wrapper';
+import {
+    CompilerOptions,
+    ContractArtifact,
+    ContractNetworkData,
+    ContractNetworks,
+    ContractSourceData,
+    ContractSpecificSourceData,
+    ContractVersionData,
+} from './utils/types';
+import { utils } from './utils/utils';
+
+type TYPE_ALL_FILES_IDENTIFIER = '*';
+const ALL_CONTRACTS_IDENTIFIER = '*';
+const ALL_FILES_IDENTIFIER = '*';
+const SOLC_BIN_DIR = path.join(__dirname, '..', '..', 'solc_bin');
+const DEFAULT_CONTRACTS_DIR = path.resolve('contracts');
+const DEFAULT_ARTIFACTS_DIR = path.resolve('artifacts');
+// Solc compiler settings cannot be configured from the commandline.
+// If you need this configured, please create a `compiler.json` config file
+// with your desired configurations.
+const DEFAULT_COMPILER_SETTINGS: solc.CompilerSettings = {
+    optimizer: {
+        enabled: false,
+    },
+    outputSelection: {
+        [ALL_FILES_IDENTIFIER]: {
+            [ALL_CONTRACTS_IDENTIFIER]: ['abi', 'evm.bytecode.object'],
+        },
+    },
+};
+const CONFIG_FILE = 'compiler.json';
+
+/**
+ * The Compiler facilitates compiling Solidity smart contracts and saves the results
+ * to artifact files.
+ */
+export class Compiler {
+    private _resolver: Resolver;
+    private _nameResolver: NameResolver;
+    private _contractsDir: string;
+    private _compilerSettings: solc.CompilerSettings;
+    private _artifactsDir: string;
+    private _specifiedContracts: string[] | TYPE_ALL_FILES_IDENTIFIER;
+    /**
+     * Instantiates a new instance of the Compiler class.
+     * @return An instance of the Compiler class.
+     */
+    constructor(opts: CompilerOptions) {
+        // TODO: Look for config file in parent directories if not found in current directory
+        const config: CompilerOptions = fs.existsSync(CONFIG_FILE)
+            ? JSON.parse(fs.readFileSync(CONFIG_FILE).toString())
+            : {};
+        this._contractsDir = opts.contractsDir || config.contractsDir || DEFAULT_CONTRACTS_DIR;
+        this._compilerSettings = opts.compilerSettings || config.compilerSettings || DEFAULT_COMPILER_SETTINGS;
+        this._artifactsDir = opts.artifactsDir || config.artifactsDir || DEFAULT_ARTIFACTS_DIR;
+        this._specifiedContracts = opts.contracts || config.contracts || ALL_CONTRACTS_IDENTIFIER;
+        this._nameResolver = new NameResolver(path.resolve(this._contractsDir));
+        const resolver = new FallthroughResolver();
+        resolver.appendResolver(new URLResolver());
+        const packagePath = path.resolve('');
+        resolver.appendResolver(new NPMResolver(packagePath));
+        resolver.appendResolver(new RelativeFSResolver(this._contractsDir));
+        resolver.appendResolver(new FSResolver());
+        resolver.appendResolver(this._nameResolver);
+        this._resolver = resolver;
+    }
+    /**
+     * Compiles selected Solidity files found in `contractsDir` and writes JSON artifacts to `artifactsDir`.
+     */
+    public async compileAsync(): Promise<void> {
+        await createDirIfDoesNotExistAsync(this._artifactsDir);
+        await createDirIfDoesNotExistAsync(SOLC_BIN_DIR);
+        let contractNamesToCompile: string[] = [];
+        if (this._specifiedContracts === ALL_CONTRACTS_IDENTIFIER) {
+            const allContracts = this._nameResolver.getAll();
+            contractNamesToCompile = _.map(allContracts, contractSource =>
+                path.basename(contractSource.path, constants.SOLIDITY_FILE_EXTENSION),
+            );
+        } else {
+            contractNamesToCompile = this._specifiedContracts;
+        }
+        for (const contractNameToCompile of contractNamesToCompile) {
+            await this._compileContractAsync(contractNameToCompile);
+        }
+    }
+    /**
+     * Compiles contract and saves artifact to artifactsDir.
+     * @param fileName Name of contract with '.sol' extension.
+     */
+    private async _compileContractAsync(contractName: string): Promise<void> {
+        const contractSource = this._resolver.resolve(contractName);
+        const absoluteContractPath = path.join(this._contractsDir, contractSource.path);
+        const currentArtifactIfExists = await getContractArtifactIfExistsAsync(this._artifactsDir, contractName);
+        const sourceTreeHashHex = `0x${this._getSourceTreeHash(absoluteContractPath).toString('hex')}`;
+        let shouldCompile = false;
+        if (_.isUndefined(currentArtifactIfExists)) {
+            shouldCompile = true;
+        } else {
+            const currentArtifact = currentArtifactIfExists as ContractArtifact;
+            const isUserOnLatestVersion = currentArtifact.schemaVersion === constants.LATEST_ARTIFACT_VERSION;
+            const didCompilerSettingsChange = !_.isEqual(currentArtifact.compiler.settings, this._compilerSettings);
+            const didSourceChange = currentArtifact.sourceTreeHashHex !== sourceTreeHashHex;
+            shouldCompile = !isUserOnLatestVersion || didCompilerSettingsChange || didSourceChange;
+        }
+        if (!shouldCompile) {
+            return;
+        }
+        const solcVersionRange = parseSolidityVersionRange(contractSource.source);
+        const availableCompilerVersions = _.keys(binPaths);
+        const solcVersion = semver.maxSatisfying(availableCompilerVersions, solcVersionRange);
+        const fullSolcVersion = binPaths[solcVersion];
+        const compilerBinFilename = path.join(SOLC_BIN_DIR, fullSolcVersion);
+        let solcjs: string;
+        const isCompilerAvailableLocally = fs.existsSync(compilerBinFilename);
+        if (isCompilerAvailableLocally) {
+            solcjs = fs.readFileSync(compilerBinFilename).toString();
+        } else {
+            logUtils.log(`Downloading ${fullSolcVersion}...`);
+            const url = `${constants.BASE_COMPILER_URL}${fullSolcVersion}`;
+            const response = await fetch(url);
+            if (response.status !== 200) {
+                throw new Error(`Failed to load ${fullSolcVersion}`);
+            }
+            solcjs = await response.text();
+            fs.writeFileSync(compilerBinFilename, solcjs);
+        }
+        const solcInstance = solc.setupMethods(requireFromString(solcjs, compilerBinFilename));
+
+        logUtils.log(`Compiling ${contractName} with Solidity v${solcVersion}...`);
+        const source = contractSource.source;
+        const standardInput: solc.StandardInput = {
+            language: 'Solidity',
+            sources: {
+                [contractSource.path]: {
+                    content: contractSource.source,
+                },
+            },
+            settings: this._compilerSettings,
+        };
+        const compiled: solc.StandardOutput = JSON.parse(
+            solcInstance.compileStandardWrapper(JSON.stringify(standardInput), importPath => {
+                const sourceCodeIfExists = this._resolver.resolve(importPath);
+                return { contents: sourceCodeIfExists.source };
+            }),
+        );
+
+        if (!_.isUndefined(compiled.errors)) {
+            const SOLIDITY_WARNING = 'warning';
+            const errors = _.filter(compiled.errors, entry => entry.severity !== SOLIDITY_WARNING);
+            const warnings = _.filter(compiled.errors, entry => entry.severity === SOLIDITY_WARNING);
+            if (!_.isEmpty(errors)) {
+                errors.forEach(error => {
+                    const normalizedErrMsg = getNormalizedErrMsg(error.formattedMessage || error.message);
+                    logUtils.log(chalk.red(normalizedErrMsg));
+                });
+                process.exit(1);
+            } else {
+                warnings.forEach(warning => {
+                    const normalizedWarningMsg = getNormalizedErrMsg(warning.formattedMessage || warning.message);
+                    logUtils.log(chalk.yellow(normalizedWarningMsg));
+                });
+            }
+        }
+        const compiledData = compiled.contracts[contractSource.path][contractName];
+        if (_.isUndefined(compiledData)) {
+            throw new Error(
+                `Contract ${contractName} not found in ${
+                    contractSource.path
+                }. Please make sure your contract has the same name as it's file name`,
+            );
+        }
+        if (!_.isUndefined(compiledData.evm)) {
+            if (!_.isUndefined(compiledData.evm.bytecode) && !_.isUndefined(compiledData.evm.bytecode.object)) {
+                compiledData.evm.bytecode.object = ethUtil.addHexPrefix(compiledData.evm.bytecode.object);
+            }
+            if (
+                !_.isUndefined(compiledData.evm.deployedBytecode) &&
+                !_.isUndefined(compiledData.evm.deployedBytecode.object)
+            ) {
+                compiledData.evm.deployedBytecode.object = ethUtil.addHexPrefix(
+                    compiledData.evm.deployedBytecode.object,
+                );
+            }
+        }
+
+        const sourceCodes = _.mapValues(
+            compiled.sources,
+            (_1, sourceFilePath) => this._resolver.resolve(sourceFilePath).source,
+        );
+        const contractVersion: ContractVersionData = {
+            compilerOutput: compiledData,
+            sources: compiled.sources,
+            sourceCodes,
+            sourceTreeHashHex,
+            compiler: {
+                name: 'solc',
+                version: solcVersion,
+                settings: this._compilerSettings,
+            },
+        };
+
+        let newArtifact: ContractArtifact;
+        if (!_.isUndefined(currentArtifactIfExists)) {
+            const currentArtifact = currentArtifactIfExists as ContractArtifact;
+            newArtifact = {
+                ...currentArtifact,
+                ...contractVersion,
+            };
+        } else {
+            newArtifact = {
+                schemaVersion: constants.LATEST_ARTIFACT_VERSION,
+                contractName,
+                ...contractVersion,
+                networks: {},
+            };
+        }
+
+        const artifactString = utils.stringifyWithFormatting(newArtifact);
+        const currentArtifactPath = `${this._artifactsDir}/${contractName}.json`;
+        await fsWrapper.writeFileAsync(currentArtifactPath, artifactString);
+        logUtils.log(`${contractName} artifact saved!`);
+    }
+    /**
+     * Gets the source tree hash for a file and its dependencies.
+     * @param fileName Name of contract file.
+     */
+    private _getSourceTreeHash(importPath: string): Buffer {
+        const contractSource = this._resolver.resolve(importPath);
+        const dependencies = parseDependencies(contractSource);
+        const sourceHash = ethUtil.sha3(contractSource.source);
+        if (dependencies.length === 0) {
+            return sourceHash;
+        } else {
+            const dependencySourceTreeHashes = _.map(dependencies, (dependency: string) =>
+                this._getSourceTreeHash(dependency),
+            );
+            const sourceTreeHashesBuffer = Buffer.concat([sourceHash, ...dependencySourceTreeHashes]);
+            const sourceTreeHash = ethUtil.sha3(sourceTreeHashesBuffer);
+            return sourceTreeHash;
+        }
+    }
+}
diff --git a/packages/sol-compiler/src/globals.d.ts b/packages/sol-compiler/src/globals.d.ts
new file mode 100644
index 000000000..94e63a32d
--- /dev/null
+++ b/packages/sol-compiler/src/globals.d.ts
@@ -0,0 +1,6 @@
+declare module '*.json' {
+    const json: any;
+    /* tslint:disable */
+    export default json;
+    /* tslint:enable */
+}
diff --git a/packages/sol-compiler/src/index.ts b/packages/sol-compiler/src/index.ts
new file mode 100644
index 000000000..4b4c51de2
--- /dev/null
+++ b/packages/sol-compiler/src/index.ts
@@ -0,0 +1,2 @@
+export { Compiler } from './compiler';
+export { ContractArtifact, ContractNetworks } from './utils/types';
diff --git a/packages/sol-compiler/src/monorepo_scripts/postpublish.ts b/packages/sol-compiler/src/monorepo_scripts/postpublish.ts
new file mode 100644
index 000000000..dcb99d0f7
--- /dev/null
+++ b/packages/sol-compiler/src/monorepo_scripts/postpublish.ts
@@ -0,0 +1,8 @@
+import { postpublishUtils } from '@0xproject/monorepo-scripts';
+
+import * as packageJSON from '../package.json';
+import * as tsConfigJSON from '../tsconfig.json';
+
+const cwd = `${__dirname}/..`;
+// tslint:disable-next-line:no-floating-promises
+postpublishUtils.runAsync(packageJSON, tsConfigJSON, cwd);
diff --git a/packages/sol-compiler/src/monorepo_scripts/stage_docs.ts b/packages/sol-compiler/src/monorepo_scripts/stage_docs.ts
new file mode 100644
index 000000000..e732ac8eb
--- /dev/null
+++ b/packages/sol-compiler/src/monorepo_scripts/stage_docs.ts
@@ -0,0 +1,8 @@
+import { postpublishUtils } from '@0xproject/monorepo-scripts';
+
+import * as packageJSON from '../package.json';
+import * as tsConfigJSON from '../tsconfig.json';
+
+const cwd = `${__dirname}/..`;
+// tslint:disable-next-line:no-floating-promises
+postpublishUtils.publishDocsToStagingAsync(packageJSON, tsConfigJSON, cwd);
diff --git a/packages/sol-compiler/src/solc/bin_paths.ts b/packages/sol-compiler/src/solc/bin_paths.ts
new file mode 100644
index 000000000..1b5e8c6f1
--- /dev/null
+++ b/packages/sol-compiler/src/solc/bin_paths.ts
@@ -0,0 +1,20 @@
+export interface BinaryPaths {
+    [key: string]: string;
+}
+
+export const binPaths: BinaryPaths = {
+    '0.4.10': 'soljson-v0.4.10+commit.f0d539ae.js',
+    '0.4.11': 'soljson-v0.4.11+commit.68ef5810.js',
+    '0.4.12': 'soljson-v0.4.12+commit.194ff033.js',
+    '0.4.13': 'soljson-v0.4.13+commit.fb4cb1a.js',
+    '0.4.14': 'soljson-v0.4.14+commit.c2215d46.js',
+    '0.4.15': 'soljson-v0.4.15+commit.bbb8e64f.js',
+    '0.4.16': 'soljson-v0.4.16+commit.d7661dd9.js',
+    '0.4.17': 'soljson-v0.4.17+commit.bdeb9e52.js',
+    '0.4.18': 'soljson-v0.4.18+commit.9cf6e910.js',
+    '0.4.19': 'soljson-v0.4.19+commit.c4cbbb05.js',
+    '0.4.20': 'soljson-v0.4.20+commit.3155dd80.js',
+    '0.4.21': 'soljson-v0.4.21+commit.dfe3193c.js',
+    '0.4.22': 'soljson-v0.4.22+commit.4cb486ee.js',
+    '0.4.23': 'soljson-v0.4.23+commit.124ca40d.js',
+};
diff --git a/packages/sol-compiler/src/utils/compiler.ts b/packages/sol-compiler/src/utils/compiler.ts
new file mode 100644
index 000000000..3731385e2
--- /dev/null
+++ b/packages/sol-compiler/src/utils/compiler.ts
@@ -0,0 +1,107 @@
+import { ContractSource, ContractSources } from '@0xproject/sol-resolver';
+import { logUtils } from '@0xproject/utils';
+import * as _ from 'lodash';
+import * as path from 'path';
+import * as solc from 'solc';
+
+import { constants } from './constants';
+import { fsWrapper } from './fs_wrapper';
+import { ContractArtifact } from './types';
+
+/**
+ * Gets contract data on network or returns if an artifact does not exist.
+ * @param artifactsDir Path to the artifacts directory.
+ * @param contractName Name of contract.
+ * @return Contract data on network or undefined.
+ */
+export async function getContractArtifactIfExistsAsync(
+    artifactsDir: string,
+    contractName: string,
+): Promise<ContractArtifact | void> {
+    let contractArtifact;
+    const currentArtifactPath = `${artifactsDir}/${contractName}.json`;
+    try {
+        const opts = {
+            encoding: 'utf8',
+        };
+        const contractArtifactString = await fsWrapper.readFileAsync(currentArtifactPath, opts);
+        contractArtifact = JSON.parse(contractArtifactString);
+        return contractArtifact;
+    } catch (err) {
+        logUtils.log(`Artifact for ${contractName} does not exist`);
+        return undefined;
+    }
+}
+
+/**
+ * Creates a directory if it does not already exist.
+ * @param artifactsDir Path to the directory.
+ */
+export async function createDirIfDoesNotExistAsync(dirPath: string): Promise<void> {
+    if (!fsWrapper.doesPathExistSync(dirPath)) {
+        logUtils.log(`Creating directory at ${dirPath}...`);
+        await fsWrapper.mkdirpAsync(dirPath);
+    }
+}
+
+/**
+ * Searches Solidity source code for compiler version range.
+ * @param  source Source code of contract.
+ * @return Solc compiler version range.
+ */
+export function parseSolidityVersionRange(source: string): string {
+    const SOLIDITY_VERSION_RANGE_REGEX = /pragma\s+solidity\s+(.*);/;
+    const solcVersionRangeMatch = source.match(SOLIDITY_VERSION_RANGE_REGEX);
+    if (_.isNull(solcVersionRangeMatch)) {
+        throw new Error('Could not find Solidity version range in source');
+    }
+    const solcVersionRange = solcVersionRangeMatch[1];
+    return solcVersionRange;
+}
+
+/**
+ * Normalizes the path found in the error message.
+ * Example: converts 'base/Token.sol:6:46: Warning: Unused local variable'
+ *          to 'Token.sol:6:46: Warning: Unused local variable'
+ * This is used to prevent logging the same error multiple times.
+ * @param  errMsg An error message from the compiled output.
+ * @return The error message with directories truncated from the contract path.
+ */
+export function getNormalizedErrMsg(errMsg: string): string {
+    const SOLIDITY_FILE_EXTENSION_REGEX = /(.*\.sol)/;
+    const errPathMatch = errMsg.match(SOLIDITY_FILE_EXTENSION_REGEX);
+    if (_.isNull(errPathMatch)) {
+        throw new Error('Could not find a path in error message');
+    }
+    const errPath = errPathMatch[0];
+    const baseContract = path.basename(errPath);
+    const normalizedErrMsg = errMsg.replace(errPath, baseContract);
+    return normalizedErrMsg;
+}
+
+/**
+ * Parses the contract source code and extracts the dendencies
+ * @param  source Contract source code
+ * @return List of dependendencies
+ */
+export function parseDependencies(contractSource: ContractSource): string[] {
+    // TODO: Use a proper parser
+    const source = contractSource.source;
+    const IMPORT_REGEX = /(import\s)/;
+    const DEPENDENCY_PATH_REGEX = /"([^"]+)"/; // Source: https://github.com/BlockChainCompany/soljitsu/blob/master/lib/shared.js
+    const dependencies: string[] = [];
+    const lines = source.split('\n');
+    _.forEach(lines, line => {
+        if (!_.isNull(line.match(IMPORT_REGEX))) {
+            const dependencyMatch = line.match(DEPENDENCY_PATH_REGEX);
+            if (!_.isNull(dependencyMatch)) {
+                let dependencyPath = dependencyMatch[1];
+                if (dependencyPath.startsWith('.')) {
+                    dependencyPath = path.join(path.dirname(contractSource.path), dependencyPath);
+                }
+                dependencies.push(dependencyPath);
+            }
+        }
+    });
+    return dependencies;
+}
diff --git a/packages/sol-compiler/src/utils/constants.ts b/packages/sol-compiler/src/utils/constants.ts
new file mode 100644
index 000000000..df2ddb3b2
--- /dev/null
+++ b/packages/sol-compiler/src/utils/constants.ts
@@ -0,0 +1,5 @@
+export const constants = {
+    SOLIDITY_FILE_EXTENSION: '.sol',
+    BASE_COMPILER_URL: 'https://ethereum.github.io/solc-bin/bin/',
+    LATEST_ARTIFACT_VERSION: '2.0.0',
+};
diff --git a/packages/sol-compiler/src/utils/encoder.ts b/packages/sol-compiler/src/utils/encoder.ts
new file mode 100644
index 000000000..806efbbca
--- /dev/null
+++ b/packages/sol-compiler/src/utils/encoder.ts
@@ -0,0 +1,18 @@
+import { AbiDefinition, AbiType, ContractAbi, DataItem } from '@0xproject/types';
+import * as _ from 'lodash';
+import * as web3Abi from 'web3-eth-abi';
+
+export const encoder = {
+    encodeConstructorArgsFromAbi(args: any[], abi: ContractAbi): string {
+        const constructorTypes: string[] = [];
+        _.each(abi, (element: AbiDefinition) => {
+            if (element.type === AbiType.Constructor) {
+                _.each(element.inputs, (input: DataItem) => {
+                    constructorTypes.push(input.type);
+                });
+            }
+        });
+        const encodedParameters = web3Abi.encodeParameters(constructorTypes, args);
+        return encodedParameters;
+    },
+};
diff --git a/packages/sol-compiler/src/utils/fs_wrapper.ts b/packages/sol-compiler/src/utils/fs_wrapper.ts
new file mode 100644
index 000000000..cc7b06175
--- /dev/null
+++ b/packages/sol-compiler/src/utils/fs_wrapper.ts
@@ -0,0 +1,13 @@
+import { promisify } from '@0xproject/utils';
+import * as fs from 'fs';
+import * as mkdirp from 'mkdirp';
+
+export const fsWrapper = {
+    readdirAsync: promisify<string[]>(fs.readdir),
+    readFileAsync: promisify<string>(fs.readFile),
+    writeFileAsync: promisify<undefined>(fs.writeFile),
+    mkdirpAsync: promisify<undefined>(mkdirp),
+    doesPathExistSync: fs.existsSync,
+    rmdirSync: fs.rmdirSync,
+    removeFileAsync: promisify<undefined>(fs.unlink),
+};
diff --git a/packages/sol-compiler/src/utils/types.ts b/packages/sol-compiler/src/utils/types.ts
new file mode 100644
index 000000000..b12a11b79
--- /dev/null
+++ b/packages/sol-compiler/src/utils/types.ts
@@ -0,0 +1,79 @@
+import { ContractAbi, Provider, TxData } from '@0xproject/types';
+import * as solc from 'solc';
+import * as Web3 from 'web3';
+import * as yargs from 'yargs';
+
+export enum AbiType {
+    Function = 'function',
+    Constructor = 'constructor',
+    Event = 'event',
+    Fallback = 'fallback',
+}
+
+export interface ContractArtifact extends ContractVersionData {
+    schemaVersion: string;
+    contractName: string;
+    networks: ContractNetworks;
+}
+
+export interface ContractVersionData {
+    compiler: {
+        name: 'solc';
+        version: string;
+        settings: solc.CompilerSettings;
+    };
+    sources: {
+        [sourceName: string]: {
+            id: number;
+        };
+    };
+    sourceCodes: {
+        [sourceName: string]: string;
+    };
+    sourceTreeHashHex: string;
+    compilerOutput: solc.StandardContractOutput;
+}
+
+export interface ContractNetworks {
+    [networkId: number]: ContractNetworkData;
+}
+
+export interface ContractNetworkData {
+    address: string;
+    links: {
+        [linkName: string]: string;
+    };
+    constructorArgs: string;
+}
+
+export interface SolcErrors {
+    [key: string]: boolean;
+}
+
+export interface CompilerOptions {
+    contractsDir?: string;
+    artifactsDir?: string;
+    compilerSettings?: solc.CompilerSettings;
+    contracts?: string[] | '*';
+}
+
+export interface ContractSourceData {
+    [contractName: string]: ContractSpecificSourceData;
+}
+
+export interface ContractSpecificSourceData {
+    solcVersionRange: string;
+    sourceHash: Buffer;
+    sourceTreeHash: Buffer;
+}
+
+export interface Token {
+    address?: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    ipfsHash: string;
+    swarmHash: string;
+}
+
+export type DoneCallback = (err?: Error) => void;
diff --git a/packages/sol-compiler/src/utils/utils.ts b/packages/sol-compiler/src/utils/utils.ts
new file mode 100644
index 000000000..4f2de2caa
--- /dev/null
+++ b/packages/sol-compiler/src/utils/utils.ts
@@ -0,0 +1,6 @@
+export const utils = {
+    stringifyWithFormatting(obj: any): string {
+        const stringifiedObj = JSON.stringify(obj, null, '\t');
+        return stringifiedObj;
+    },
+};