Update dependency packages

4 files changed, 0 insertions, 301 deletions

diff --git a/packages/abi-gen/src/globals.d.ts b/packages/abi-gen/src/globals.d.ts
deleted file mode 100644
index 94e63a32d..000000000
--- a/packages/abi-gen/src/globals.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-declare module '*.json' {
-    const json: any;
-    /* tslint:disable */
-    export default json;
-    /* tslint:enable */
-}
diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts
deleted file mode 100644
index 6e0ca2c87..000000000
--- a/packages/abi-gen/src/index.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-
-import { AbiEncoder, abiUtils, logUtils } from '@0x/utils';
-import chalk from 'chalk';
-import { AbiDefinition, ConstructorAbi, EventAbi, MethodAbi } from 'ethereum-types';
-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 { ContextData, ContractsBackend, ParamKind } from './types';
-import { utils } from './utils';
-
-const ABI_TYPE_CONSTRUCTOR = 'constructor';
-const ABI_TYPE_METHOD = 'function';
-const ABI_TYPE_EVENT = 'event';
-const DEFAULT_NETWORK_ID = 50;
-const DEFAULT_BACKEND = 'web3';
-
-const args = yargs
-    .option('abis', {
-        describe: 'Glob pattern to search for ABI JSON files',
-        type: 'string',
-        demandOption: true,
-    })
-    .option('output', {
-        alias: ['o', 'out'],
-        describe: 'Folder where to put the output files',
-        type: 'string',
-        normalize: true,
-        demandOption: true,
-    })
-    .option('partials', {
-        describe: 'Glob pattern for the partial template files',
-        type: 'string',
-        implies: 'template',
-    })
-    .option('template', {
-        describe: 'Path for the main template file that will be used to generate each contract',
-        type: 'string',
-        demandOption: true,
-        normalize: true,
-    })
-    .option('backend', {
-        describe: `The backing Ethereum library your app uses. Either 'web3' or 'ethers'. Ethers auto-converts small ints to numbers whereas Web3 doesn't.`,
-        type: 'string',
-        choices: [ContractsBackend.Web3, ContractsBackend.Ethers],
-        default: DEFAULT_BACKEND,
-    })
-    .option('network-id', {
-        describe: 'ID of the network where contract ABIs are nested in artifacts',
-        type: 'number',
-        default: DEFAULT_NETWORK_ID,
-    })
-    .example(
-        "$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'",
-        'Full usage example',
-    ).argv;
-
-function registerPartials(partialsGlob: string): void {
-    const partialTemplateFileNames = globSync(partialsGlob);
-    logUtils.log(`Found ${chalk.green(`${partialTemplateFileNames.length}`)} ${chalk.bold('partial')} templates`);
-    for (const partialTemplateFileName of partialTemplateFileNames) {
-        const namedContent = utils.getNamedContent(partialTemplateFileName);
-        Handlebars.registerPartial(namedContent.name, namedContent.content);
-    }
-}
-
-Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input, args.backend));
-Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output, args.backend));
-if (args.partials) {
-    registerPartials(args.partials);
-}
-const mainTemplate = utils.getNamedContent(args.template);
-const template = Handlebars.compile<ContextData>(mainTemplate.content);
-const abiFileNames = globSync(args.abis);
-
-if (_.isEmpty(abiFileNames)) {
-    logUtils.log(`${chalk.red(`No ABI files found.`)}`);
-    logUtils.log(`Please make sure you've passed the correct folder name and that the files have
-               ${chalk.bold('*.json')} extensions`);
-    process.exit(1);
-} else {
-    logUtils.log(`Found ${chalk.green(`${abiFileNames.length}`)} ${chalk.bold('ABI')} files`);
-    mkdirp.sync(args.output);
-}
-for (const abiFileName of abiFileNames) {
-    const namedContent = utils.getNamedContent(abiFileName);
-    logUtils.log(`Processing: ${chalk.bold(namedContent.name)}...`);
-    const parsedContent = JSON.parse(namedContent.content);
-    let ABI;
-    if (_.isArray(parsedContent)) {
-        ABI = parsedContent; // ABI file
-    } else if (!_.isUndefined(parsedContent.abi)) {
-        ABI = parsedContent.abi; // Truffle artifact
-    } else if (!_.isUndefined(parsedContent.compilerOutput.abi)) {
-        ABI = parsedContent.compilerOutput.abi; // 0x artifact
-    }
-    if (_.isUndefined(ABI)) {
-        logUtils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
-        logUtils.log(
-            `Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x sol-compiler artifact`,
-        );
-        process.exit(1);
-    }
-
-    const outFileName = utils.makeOutputFileName(namedContent.name);
-    const outFilePath = `${args.output}/${outFileName}.ts`;
-
-    if (utils.isOutputFileUpToDate(abiFileName, outFilePath)) {
-        logUtils.log(`Already up to date: ${chalk.bold(outFilePath)}`);
-        continue;
-    }
-
-    let ctor = ABI.find((abi: AbiDefinition) => abi.type === ABI_TYPE_CONSTRUCTOR) as ConstructorAbi;
-    if (_.isUndefined(ctor)) {
-        ctor = utils.getEmptyConstructor(); // The constructor exists, but it's implicit in JSON's ABI definition
-    }
-
-    const methodAbis = ABI.filter((abi: AbiDefinition) => abi.type === ABI_TYPE_METHOD) as MethodAbi[];
-    const sanitizedMethodAbis = abiUtils.renameOverloadedMethods(methodAbis) as MethodAbi[];
-    const methodsData = _.map(methodAbis, (methodAbi, methodAbiIndex: number) => {
-        _.forEach(methodAbi.inputs, (input, inputIndex: number) => {
-            if (_.isEmpty(input.name)) {
-                // Auto-generated getters don't have parameter names
-                input.name = `index_${inputIndex}`;
-            }
-        });
-        // This will make templates simpler
-        const methodData = {
-            ...methodAbi,
-            singleReturnValue: methodAbi.outputs.length === 1,
-            hasReturnValue: methodAbi.outputs.length !== 0,
-            tsName: sanitizedMethodAbis[methodAbiIndex].name,
-            functionSignature: new AbiEncoder.Method(methodAbi).getSignature(),
-        };
-        return methodData;
-    });
-
-    const eventAbis = ABI.filter((abi: AbiDefinition) => abi.type === ABI_TYPE_EVENT) as EventAbi[];
-
-    const contextData = {
-        contractName: namedContent.name,
-        ctor,
-        methods: methodsData,
-        events: eventAbis,
-    };
-    const renderedTsCode = template(contextData);
-    utils.writeOutputFile(outFilePath, renderedTsCode);
-    logUtils.log(`Created: ${chalk.bold(outFilePath)}`);
-}
diff --git a/packages/abi-gen/src/types.ts b/packages/abi-gen/src/types.ts
deleted file mode 100644
index 68765b04d..000000000
--- a/packages/abi-gen/src/types.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { EventAbi, MethodAbi } from 'ethereum-types';
-
-export enum ParamKind {
-    Input = 'input',
-    Output = 'output',
-}
-
-export enum ContractsBackend {
-    Web3 = 'web3',
-    Ethers = 'ethers',
-}
-
-export interface Method extends MethodAbi {
-    singleReturnValue: boolean;
-    hasReturnValue: boolean;
-    tsName: string;
-    functionSignature: string;
-}
-
-export interface ContextData {
-    contractName: string;
-    methods: Method[];
-    events: EventAbi[];
-}
diff --git a/packages/abi-gen/src/utils.ts b/packages/abi-gen/src/utils.ts
deleted file mode 100644
index 56b996ce3..000000000
--- a/packages/abi-gen/src/utils.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { AbiType, ConstructorAbi, DataItem } from 'ethereum-types';
-import * as fs from 'fs';
-import * as _ from 'lodash';
-import * as path from 'path';
-import toSnakeCase = require('to-snake-case');
-
-import { ContractsBackend, ParamKind } from './types';
-
-export const utils = {
-    solTypeToTsType(paramKind: ParamKind, backend: ContractsBackend, solType: string, components?: DataItem[]): string {
-        const trailingArrayRegex = /\[\d*\]$/;
-        if (solType.match(trailingArrayRegex)) {
-            const arrayItemSolType = solType.replace(trailingArrayRegex, '');
-            const arrayItemTsType = utils.solTypeToTsType(paramKind, backend, arrayItemSolType, components);
-            const arrayTsType =
-                utils.isUnionType(arrayItemTsType) || utils.isObjectType(arrayItemTsType)
-                    ? `Array<${arrayItemTsType}>`
-                    : `${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 and ethers allow to pass those as numbers instead of bignumbers
-                solTypeRegexToTsType.unshift({
-                    regex: '^u?int(8|16|32)?$',
-                    tsType: 'number|BigNumber',
-                });
-            }
-            if (backend === ContractsBackend.Ethers && paramKind === ParamKind.Output) {
-                // ethers-contracts automatically converts small BigNumbers to numbers
-                solTypeRegexToTsType.unshift({
-                    regex: '^u?int(8|16|32|48)?$',
-                    tsType: 'number',
-                });
-            }
-            for (const regexAndTxType of solTypeRegexToTsType) {
-                const { regex, tsType } = regexAndTxType;
-                if (solType.match(regex)) {
-                    return tsType;
-                }
-            }
-            const TUPLE_TYPE_REGEX = '^tuple$';
-            if (solType.match(TUPLE_TYPE_REGEX)) {
-                const componentsType = _.map(components, component => {
-                    const componentValueType = utils.solTypeToTsType(
-                        paramKind,
-                        backend,
-                        component.type,
-                        component.components,
-                    );
-                    const componentType = `${component.name}: ${componentValueType}`;
-                    return componentType;
-                });
-                const tsType = `{${componentsType.join(';')}}`;
-                return tsType;
-            }
-            throw new Error(`Unknown Solidity type found: ${solType}`);
-        }
-    },
-    isUnionType(tsType: string): boolean {
-        return tsType === 'number|BigNumber';
-    },
-    isObjectType(tsType: string): boolean {
-        return /^{.*}$/.test(tsType);
-    },
-    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}`);
-        }
-    },
-    getEmptyConstructor(): ConstructorAbi {
-        return {
-            type: AbiType.Constructor,
-            stateMutability: 'nonpayable',
-            payable: false,
-            inputs: [],
-        };
-    },
-    makeOutputFileName(name: string): string {
-        let fileName = toSnakeCase(name);
-        // HACK: Snake case doesn't make a lot of sense for abbreviated names but we can't reliably detect abbreviations
-        // so we special-case the abbreviations we use.
-        fileName = fileName.replace('z_r_x', 'zrx').replace('e_r_c', 'erc');
-        return fileName;
-    },
-    writeOutputFile(filePath: string, renderedTsCode: string): void {
-        fs.writeFileSync(filePath, renderedTsCode);
-    },
-    isOutputFileUpToDate(abiFile: string, outputFile: string): boolean {
-        const abiFileModTimeMs = fs.statSync(abiFile).mtimeMs;
-        try {
-            const outFileModTimeMs = fs.statSync(outputFile).mtimeMs;
-            return outFileModTimeMs > abiFileModTimeMs;
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                return false;
-            } else {
-                throw err;
-            }
-        }
-    },
-};