Update dependency packages

44 files changed, 0 insertions, 2831 deletions

diff --git a/packages/utils/src/abi_decoder.ts b/packages/utils/src/abi_decoder.ts
deleted file mode 100644
index 28b6418d8..000000000
--- a/packages/utils/src/abi_decoder.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import {
-    AbiDefinition,
-    AbiType,
-    DecodedLogArgs,
-    EventAbi,
-    EventParameter,
-    LogEntry,
-    LogWithDecodedArgs,
-    RawLog,
-    SolidityTypes,
-} from 'ethereum-types';
-import * as ethers from 'ethers';
-import * as _ from 'lodash';
-
-import { addressUtils } from './address_utils';
-import { BigNumber } from './configured_bignumber';
-
-/**
- * AbiDecoder allows you to decode event logs given a set of supplied contract ABI's. It takes the contract's event
- * signature from the ABI and attempts to decode the logs using it.
- */
-export class AbiDecoder {
-    private readonly _methodIds: { [signatureHash: string]: { [numIndexedArgs: number]: EventAbi } } = {};
-    /**
-     * Instantiate an AbiDecoder
-     * @param abiArrays An array of contract ABI's
-     * @return AbiDecoder instance
-     */
-    constructor(abiArrays: AbiDefinition[][]) {
-        _.forEach(abiArrays, this.addABI.bind(this));
-    }
-    /**
-     * Attempt to decode a log given the ABI's the AbiDecoder knows about.
-     * @param log The log to attempt to decode
-     * @return The decoded log if the requisite ABI was available. Otherwise the log unaltered.
-     */
-    public tryToDecodeLogOrNoop<ArgsType extends DecodedLogArgs>(log: LogEntry): LogWithDecodedArgs<ArgsType> | RawLog {
-        const methodId = log.topics[0];
-        const numIndexedArgs = log.topics.length - 1;
-        if (_.isUndefined(this._methodIds[methodId]) || _.isUndefined(this._methodIds[methodId][numIndexedArgs])) {
-            return log;
-        }
-        const event = this._methodIds[methodId][numIndexedArgs];
-        const ethersInterface = new ethers.utils.Interface([event]);
-        const decodedParams: DecodedLogArgs = {};
-        let topicsIndex = 1;
-
-        let decodedData: any[];
-        try {
-            decodedData = ethersInterface.events[event.name].decode(log.data);
-        } catch (error) {
-            if (error.code === ethers.errors.INVALID_ARGUMENT) {
-                // Because we index events by Method ID, and Method IDs are derived from the method
-                // name and the input parameters, it's possible that the return value of the event
-                // does not match our ABI. If that's the case, then ethers will throw an error
-                // when we try to parse the event. We handle that case here by returning the log rather
-                // than throwing an error.
-                return log;
-            }
-            throw error;
-        }
-        let didFailToDecode = false;
-        _.forEach(event.inputs, (param: EventParameter, i: number) => {
-            // Indexed parameters are stored in topics. Non-indexed ones in decodedData
-            let value: BigNumber | string | number = param.indexed ? log.topics[topicsIndex++] : decodedData[i];
-            if (_.isUndefined(value)) {
-                didFailToDecode = true;
-                return;
-            }
-            if (param.type === SolidityTypes.Address) {
-                const baseHex = 16;
-                value = addressUtils.padZeros(new BigNumber((value as string).toLowerCase()).toString(baseHex));
-            } else if (param.type === SolidityTypes.Uint256 || param.type === SolidityTypes.Uint) {
-                value = new BigNumber(value);
-            } else if (param.type === SolidityTypes.Uint8) {
-                value = new BigNumber(value).toNumber();
-            }
-            decodedParams[param.name] = value;
-        });
-
-        if (didFailToDecode) {
-            return log;
-        } else {
-            return {
-                ...log,
-                event: event.name,
-                args: decodedParams,
-            };
-        }
-    }
-    /**
-     * Add additional ABI definitions to the AbiDecoder
-     * @param abiArray An array of ABI definitions to add to the AbiDecoder
-     */
-    public addABI(abiArray: AbiDefinition[]): void {
-        if (_.isUndefined(abiArray)) {
-            return;
-        }
-        const ethersInterface = new ethers.utils.Interface(abiArray);
-        _.map(abiArray, (abi: AbiDefinition) => {
-            if (abi.type === AbiType.Event) {
-                // tslint:disable-next-line:no-unnecessary-type-assertion
-                const eventAbi = abi as EventAbi;
-                const topic = ethersInterface.events[eventAbi.name].topic;
-                const numIndexedArgs = _.reduce(eventAbi.inputs, (sum, input) => (input.indexed ? sum + 1 : sum), 0);
-                this._methodIds[topic] = {
-                    ...this._methodIds[topic],
-                    [numIndexedArgs]: eventAbi,
-                };
-            }
-        });
-    }
-}
diff --git a/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts b/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts
deleted file mode 100644
index f23324721..000000000
--- a/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { DataItem } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { Calldata } from '../calldata/calldata';
-import { CalldataBlock } from '../calldata/calldata_block';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-import { DecodingRules, EncodingRules } from '../utils/rules';
-
-import { DataTypeFactory } from './interfaces';
-
-export abstract class DataType {
-    private readonly _dataItem: DataItem;
-    private readonly _factory: DataTypeFactory;
-
-    constructor(dataItem: DataItem, factory: DataTypeFactory) {
-        this._dataItem = dataItem;
-        this._factory = factory;
-    }
-
-    public getDataItem(): DataItem {
-        return this._dataItem;
-    }
-
-    public getFactory(): DataTypeFactory {
-        return this._factory;
-    }
-
-    public encode(value: any, rules?: EncodingRules, selector?: string): string {
-        const rules_ = _.isUndefined(rules) ? constants.DEFAULT_ENCODING_RULES : rules;
-        const calldata = new Calldata(rules_);
-        if (!_.isUndefined(selector)) {
-            calldata.setSelector(selector);
-        }
-        const block = this.generateCalldataBlock(value);
-        calldata.setRoot(block);
-        const encodedCalldata = calldata.toString();
-        return encodedCalldata;
-    }
-
-    public decode(calldata: string, rules?: DecodingRules, selector?: string): any {
-        if (!_.isUndefined(selector) && !_.startsWith(calldata, selector)) {
-            throw new Error(
-                `Tried to decode calldata, but it was missing the function selector. Expected prefix '${selector}'. Got '${calldata}'.`,
-            );
-        }
-        const hasSelector = !_.isUndefined(selector);
-        const rawCalldata = new RawCalldata(calldata, hasSelector);
-        const rules_ = _.isUndefined(rules) ? constants.DEFAULT_DECODING_RULES : rules;
-        const value = this.generateValue(rawCalldata, rules_);
-        return value;
-    }
-
-    public decodeAsArray(returndata: string, rules?: DecodingRules): any[] {
-        const value = this.decode(returndata, rules);
-        const valuesAsArray = _.isObject(value) ? _.values(value) : [value];
-        return valuesAsArray;
-    }
-
-    public getSignature(isDetailed?: boolean): string {
-        if (_.isEmpty(this._dataItem.name) || !isDetailed) {
-            return this.getSignatureType();
-        }
-        const name = this.getDataItem().name;
-        const lastIndexOfScopeDelimiter = name.lastIndexOf('.');
-        const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0;
-        const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name;
-        const detailedSignature = `${shortName} ${this.getSignatureType()}`;
-        return detailedSignature;
-    }
-
-    public abstract generateCalldataBlock(value: any, parentBlock?: CalldataBlock): CalldataBlock;
-    public abstract generateValue(calldata: RawCalldata, rules: DecodingRules): any;
-    public abstract getSignatureType(): string;
-    public abstract isStatic(): boolean;
-}
diff --git a/packages/utils/src/abi_encoder/abstract_data_types/interfaces.ts b/packages/utils/src/abi_encoder/abstract_data_types/interfaces.ts
deleted file mode 100644
index 2f2f60871..000000000
--- a/packages/utils/src/abi_encoder/abstract_data_types/interfaces.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { DataItem } from 'ethereum-types';
-
-import { RawCalldata } from '../calldata/raw_calldata';
-
-import { DataType } from './data_type';
-
-export interface DataTypeFactory {
-    create: (dataItem: DataItem, parentDataType?: DataType) => DataType;
-}
-
-export interface DataTypeStaticInterface {
-    matchType: (type: string) => boolean;
-    encodeValue: (value: any) => Buffer;
-    decodeValue: (rawCalldata: RawCalldata) => any;
-}
-
-export interface MemberIndexByName {
-    [key: string]: number;
-}
diff --git a/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts b/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts
deleted file mode 100644
index a091e55b9..000000000
--- a/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { DataItem } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { BlobCalldataBlock } from '../../calldata/blocks/blob';
-import { CalldataBlock } from '../../calldata/calldata_block';
-import { RawCalldata } from '../../calldata/raw_calldata';
-import { DecodingRules } from '../../utils/rules';
-
-import { DataType } from '../data_type';
-import { DataTypeFactory } from '../interfaces';
-
-export abstract class AbstractBlobDataType extends DataType {
-    protected _sizeKnownAtCompileTime: boolean;
-
-    public constructor(dataItem: DataItem, factory: DataTypeFactory, sizeKnownAtCompileTime: boolean) {
-        super(dataItem, factory);
-        this._sizeKnownAtCompileTime = sizeKnownAtCompileTime;
-    }
-
-    public generateCalldataBlock(value: any, parentBlock?: CalldataBlock): BlobCalldataBlock {
-        const encodedValue = this.encodeValue(value);
-        const name = this.getDataItem().name;
-        const signature = this.getSignature();
-        const parentName = _.isUndefined(parentBlock) ? '' : parentBlock.getName();
-        const block = new BlobCalldataBlock(name, signature, parentName, encodedValue);
-        return block;
-    }
-
-    public generateValue(calldata: RawCalldata, rules: DecodingRules): any {
-        const value = this.decodeValue(calldata);
-        return value;
-    }
-
-    public isStatic(): boolean {
-        return this._sizeKnownAtCompileTime;
-    }
-
-    public abstract encodeValue(value: any): Buffer;
-    public abstract decodeValue(calldata: RawCalldata): any;
-}
diff --git a/packages/utils/src/abi_encoder/abstract_data_types/types/pointer.ts b/packages/utils/src/abi_encoder/abstract_data_types/types/pointer.ts
deleted file mode 100644
index 0f3c55280..000000000
--- a/packages/utils/src/abi_encoder/abstract_data_types/types/pointer.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { DataItem } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { PointerCalldataBlock } from '../../calldata/blocks/pointer';
-import { CalldataBlock } from '../../calldata/calldata_block';
-import { RawCalldata } from '../../calldata/raw_calldata';
-import { constants } from '../../utils/constants';
-import { DecodingRules } from '../../utils/rules';
-
-import { DataType } from '../data_type';
-import { DataTypeFactory } from '../interfaces';
-
-export abstract class AbstractPointerDataType extends DataType {
-    protected _destination: DataType;
-    protected _parent: DataType;
-
-    public constructor(dataItem: DataItem, factory: DataTypeFactory, destination: DataType, parent: DataType) {
-        super(dataItem, factory);
-        this._destination = destination;
-        this._parent = parent;
-    }
-
-    public generateCalldataBlock(value: any, parentBlock?: CalldataBlock): PointerCalldataBlock {
-        if (_.isUndefined(parentBlock)) {
-            throw new Error(`DependentDataType requires a parent block to generate its block`);
-        }
-        const destinationBlock = this._destination.generateCalldataBlock(value, parentBlock);
-        const name = this.getDataItem().name;
-        const signature = this.getSignature();
-        const parentName = parentBlock.getName();
-        const block = new PointerCalldataBlock(name, signature, parentName, destinationBlock, parentBlock);
-        return block;
-    }
-
-    public generateValue(calldata: RawCalldata, rules: DecodingRules): any {
-        const destinationOffsetBuf = calldata.popWord();
-        const destinationOffsetHex = ethUtil.bufferToHex(destinationOffsetBuf);
-        const destinationOffsetRelative = parseInt(destinationOffsetHex, constants.HEX_BASE);
-        const destinationOffsetAbsolute = calldata.toAbsoluteOffset(destinationOffsetRelative);
-        const currentOffset = calldata.getOffset();
-        calldata.setOffset(destinationOffsetAbsolute);
-        const value = this._destination.generateValue(calldata, rules);
-        calldata.setOffset(currentOffset);
-        return value;
-    }
-
-    // Disable prefer-function-over-method for inherited abstract method.
-    /* tslint:disable prefer-function-over-method */
-    public isStatic(): boolean {
-        return true;
-    }
-    /* tslint:enable prefer-function-over-method */
-}
diff --git a/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts b/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts
deleted file mode 100644
index 2c6c4b0f6..000000000
--- a/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts
+++ /dev/null
@@ -1,224 +0,0 @@
-import { ObjectMap } from '@0x/types';
-import { DataItem } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { BigNumber } from '../../../configured_bignumber';
-import { SetCalldataBlock } from '../../calldata/blocks/set';
-import { CalldataBlock } from '../../calldata/calldata_block';
-import { RawCalldata } from '../../calldata/raw_calldata';
-import { constants } from '../../utils/constants';
-import { DecodingRules } from '../../utils/rules';
-
-import { DataType } from '../data_type';
-import { DataTypeFactory, MemberIndexByName } from '../interfaces';
-
-import { AbstractPointerDataType } from './pointer';
-
-export abstract class AbstractSetDataType extends DataType {
-    protected readonly _arrayLength: number | undefined;
-    protected readonly _arrayElementType: string | undefined;
-    private readonly _memberIndexByName: MemberIndexByName;
-    private readonly _members: DataType[];
-    private readonly _isArray: boolean;
-
-    public constructor(
-        dataItem: DataItem,
-        factory: DataTypeFactory,
-        isArray: boolean = false,
-        arrayLength?: number,
-        arrayElementType?: string,
-    ) {
-        super(dataItem, factory);
-        this._memberIndexByName = {};
-        this._members = [];
-        this._isArray = isArray;
-        this._arrayLength = arrayLength;
-        this._arrayElementType = arrayElementType;
-        if (isArray && !_.isUndefined(arrayLength)) {
-            [this._members, this._memberIndexByName] = this._createMembersWithLength(dataItem, arrayLength);
-        } else if (!isArray) {
-            [this._members, this._memberIndexByName] = this._createMembersWithKeys(dataItem);
-        }
-    }
-
-    public generateCalldataBlock(value: any[] | object, parentBlock?: CalldataBlock): SetCalldataBlock {
-        const block =
-            value instanceof Array
-                ? this._generateCalldataBlockFromArray(value, parentBlock)
-                : this._generateCalldataBlockFromObject(value, parentBlock);
-        return block;
-    }
-
-    public generateValue(calldata: RawCalldata, rules: DecodingRules): any[] | object {
-        let members = this._members;
-        // Case 1: This is an array of undefined length, which means that `this._members` was not
-        //         populated in the constructor. So we must construct the set of members now.
-        if (this._isArray && _.isUndefined(this._arrayLength)) {
-            const arrayLengthBuf = calldata.popWord();
-            const arrayLengthHex = ethUtil.bufferToHex(arrayLengthBuf);
-            const arrayLength = new BigNumber(arrayLengthHex, constants.HEX_BASE);
-            [members] = this._createMembersWithLength(this.getDataItem(), arrayLength.toNumber());
-        }
-        // Create a new scope in the calldata, before descending into the members of this set.
-        calldata.startScope();
-        let value: any[] | object;
-        if (rules.shouldConvertStructsToObjects && !this._isArray) {
-            // Construct an object with values for each member of the set.
-            value = {};
-            _.each(this._memberIndexByName, (idx: number, key: string) => {
-                const member = this._members[idx];
-                const memberValue = member.generateValue(calldata, rules);
-                (value as { [key: string]: any })[key] = memberValue;
-            });
-        } else {
-            // Construct an array with values for each member of the set.
-            value = [];
-            _.each(members, (member: DataType, idx: number) => {
-                const memberValue = member.generateValue(calldata, rules);
-                (value as any[]).push(memberValue);
-            });
-        }
-        // Close this scope and return tetheh value.
-        calldata.endScope();
-        return value;
-    }
-
-    public isStatic(): boolean {
-        // An array with an undefined length is never static.
-        if (this._isArray && _.isUndefined(this._arrayLength)) {
-            return false;
-        }
-        // If any member of the set is a pointer then the set is not static.
-        const dependentMember = _.find(this._members, (member: DataType) => {
-            return member instanceof AbstractPointerDataType;
-        });
-        const isStatic = _.isUndefined(dependentMember);
-        return isStatic;
-    }
-
-    protected _generateCalldataBlockFromArray(value: any[], parentBlock?: CalldataBlock): SetCalldataBlock {
-        // Sanity check: if the set has a defined length then `value` must have the same length.
-        if (!_.isUndefined(this._arrayLength) && value.length !== this._arrayLength) {
-            throw new Error(
-                `Expected array of ${JSON.stringify(
-                    this._arrayLength,
-                )} elements, but got array of length ${JSON.stringify(value.length)}`,
-            );
-        }
-        // Create a new calldata block for this set.
-        const parentName = _.isUndefined(parentBlock) ? '' : parentBlock.getName();
-        const block = new SetCalldataBlock(this.getDataItem().name, this.getSignature(), parentName);
-        // If this set has an undefined length then set its header to be the number of elements.
-        let members = this._members;
-        if (this._isArray && _.isUndefined(this._arrayLength)) {
-            [members] = this._createMembersWithLength(this.getDataItem(), value.length);
-            const lenBuf = ethUtil.setLengthLeft(
-                ethUtil.toBuffer(`0x${value.length.toString(constants.HEX_BASE)}`),
-                constants.EVM_WORD_WIDTH_IN_BYTES,
-            );
-            block.setHeader(lenBuf);
-        }
-        // Create blocks for members of set.
-        const memberCalldataBlocks: CalldataBlock[] = [];
-        _.each(members, (member: DataType, idx: number) => {
-            const memberBlock = member.generateCalldataBlock(value[idx], block);
-            memberCalldataBlocks.push(memberBlock);
-        });
-        block.setMembers(memberCalldataBlocks);
-        return block;
-    }
-
-    protected _generateCalldataBlockFromObject(obj: object, parentBlock?: CalldataBlock): SetCalldataBlock {
-        // Create a new calldata block for this set.
-        const parentName = _.isUndefined(parentBlock) ? '' : parentBlock.getName();
-        const block = new SetCalldataBlock(this.getDataItem().name, this.getSignature(), parentName);
-        // Create blocks for members of set.
-        const memberCalldataBlocks: CalldataBlock[] = [];
-        _.forEach(this._memberIndexByName, (memberIndex: number, memberName: string) => {
-            if (!(memberName in obj)) {
-                throw new Error(
-                    `Could not assign tuple to object: missing key '${memberName}' in object ${JSON.stringify(obj)}`,
-                );
-            }
-            const memberValue: any = (obj as ObjectMap<any>)[memberName];
-            const memberBlock = this._members[memberIndex].generateCalldataBlock(memberValue, block);
-            memberCalldataBlocks.push(memberBlock);
-        });
-        // Associate member blocks with Set block.
-        block.setMembers(memberCalldataBlocks);
-        return block;
-    }
-
-    protected _computeSignatureOfMembers(isDetailed?: boolean): string {
-        // Compute signature of members
-        let signature = `(`;
-        _.each(this._members, (member: DataType, i: number) => {
-            signature += member.getSignature(isDetailed);
-            if (i < this._members.length - 1) {
-                signature += ',';
-            }
-        });
-        signature += ')';
-        return signature;
-    }
-
-    private _createMembersWithKeys(dataItem: DataItem): [DataType[], MemberIndexByName] {
-        // Sanity check
-        if (_.isUndefined(dataItem.components)) {
-            throw new Error(
-                `Tried to create a set using key/value pairs, but no components were defined by the input DataItem '${
-                    dataItem.name
-                }'.`,
-            );
-        }
-        // Create one member for each component of `dataItem`
-        const members: DataType[] = [];
-        const memberIndexByName: MemberIndexByName = {};
-        const memberNames: string[] = [];
-        _.each(dataItem.components, (memberItem: DataItem) => {
-            // If a component with `name` already exists then
-            // rename to `name_nameIdx` to avoid naming conflicts.
-            let memberName = memberItem.name;
-            let nameIdx = 0;
-            while (_.includes(memberNames, memberName) || _.isEmpty(memberName)) {
-                nameIdx++;
-                memberName = `${memberItem.name}_${nameIdx}`;
-            }
-            memberNames.push(memberName);
-            const childDataItem: DataItem = {
-                type: memberItem.type,
-                name: `${dataItem.name}.${memberName}`,
-            };
-            const components = memberItem.components;
-            if (!_.isUndefined(components)) {
-                childDataItem.components = components;
-            }
-            const child = this.getFactory().create(childDataItem, this);
-            memberIndexByName[memberName] = members.length;
-            members.push(child);
-        });
-        return [members, memberIndexByName];
-    }
-
-    private _createMembersWithLength(dataItem: DataItem, length: number): [DataType[], MemberIndexByName] {
-        // Create `length` members, deriving the type from `dataItem`
-        const members: DataType[] = [];
-        const memberIndexByName: MemberIndexByName = {};
-        const range = _.range(length);
-        _.each(range, (idx: number) => {
-            const memberDataItem: DataItem = {
-                type: _.isUndefined(this._arrayElementType) ? '' : this._arrayElementType,
-                name: `${dataItem.name}[${idx.toString(constants.DEC_BASE)}]`,
-            };
-            const components = dataItem.components;
-            if (!_.isUndefined(components)) {
-                memberDataItem.components = components;
-            }
-            const memberType = this.getFactory().create(memberDataItem, this);
-            memberIndexByName[idx.toString(constants.DEC_BASE)] = members.length;
-            members.push(memberType);
-        });
-        return [members, memberIndexByName];
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/blocks/blob.ts b/packages/utils/src/abi_encoder/calldata/blocks/blob.ts
deleted file mode 100644
index 219ea6c61..000000000
--- a/packages/utils/src/abi_encoder/calldata/blocks/blob.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { CalldataBlock } from '../calldata_block';
-
-export class BlobCalldataBlock extends CalldataBlock {
-    private readonly _blob: Buffer;
-
-    constructor(name: string, signature: string, parentName: string, blob: Buffer) {
-        const headerSizeInBytes = 0;
-        const bodySizeInBytes = blob.byteLength;
-        super(name, signature, parentName, headerSizeInBytes, bodySizeInBytes);
-        this._blob = blob;
-    }
-
-    public toBuffer(): Buffer {
-        return this._blob;
-    }
-
-    public getRawData(): Buffer {
-        return this._blob;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/blocks/pointer.ts b/packages/utils/src/abi_encoder/calldata/blocks/pointer.ts
deleted file mode 100644
index 72d6a3173..000000000
--- a/packages/utils/src/abi_encoder/calldata/blocks/pointer.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { constants } from '../../utils/constants';
-
-import { CalldataBlock } from '../calldata_block';
-
-export class PointerCalldataBlock extends CalldataBlock {
-    public static readonly RAW_DATA_START = new Buffer('<');
-    public static readonly RAW_DATA_END = new Buffer('>');
-    private static readonly _DEPENDENT_PAYLOAD_SIZE_IN_BYTES = 32;
-    private static readonly _EMPTY_HEADER_SIZE = 0;
-    private readonly _parent: CalldataBlock;
-    private readonly _dependency: CalldataBlock;
-    private _aliasFor: CalldataBlock | undefined;
-
-    constructor(name: string, signature: string, parentName: string, dependency: CalldataBlock, parent: CalldataBlock) {
-        const headerSizeInBytes = PointerCalldataBlock._EMPTY_HEADER_SIZE;
-        const bodySizeInBytes = PointerCalldataBlock._DEPENDENT_PAYLOAD_SIZE_IN_BYTES;
-        super(name, signature, parentName, headerSizeInBytes, bodySizeInBytes);
-        this._parent = parent;
-        this._dependency = dependency;
-        this._aliasFor = undefined;
-    }
-
-    public toBuffer(): Buffer {
-        const destinationOffset = !_.isUndefined(this._aliasFor)
-            ? this._aliasFor.getOffsetInBytes()
-            : this._dependency.getOffsetInBytes();
-        const parentOffset = this._parent.getOffsetInBytes();
-        const parentHeaderSize = this._parent.getHeaderSizeInBytes();
-        const pointer: number = destinationOffset - (parentOffset + parentHeaderSize);
-        const pointerHex = `0x${pointer.toString(constants.HEX_BASE)}`;
-        const pointerBuf = ethUtil.toBuffer(pointerHex);
-        const pointerBufPadded = ethUtil.setLengthLeft(pointerBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-        return pointerBufPadded;
-    }
-
-    public getDependency(): CalldataBlock {
-        return this._dependency;
-    }
-
-    public setAlias(block: CalldataBlock): void {
-        this._aliasFor = block;
-        this._setName(`${this.getName()} (alias for ${block.getName()})`);
-    }
-
-    public getAlias(): CalldataBlock | undefined {
-        return this._aliasFor;
-    }
-
-    public getRawData(): Buffer {
-        const dependencyRawData = this._dependency.getRawData();
-        const rawDataComponents: Buffer[] = [];
-        rawDataComponents.push(PointerCalldataBlock.RAW_DATA_START);
-        rawDataComponents.push(dependencyRawData);
-        rawDataComponents.push(PointerCalldataBlock.RAW_DATA_END);
-        const rawData = Buffer.concat(rawDataComponents);
-        return rawData;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/blocks/set.ts b/packages/utils/src/abi_encoder/calldata/blocks/set.ts
deleted file mode 100644
index d1abc4986..000000000
--- a/packages/utils/src/abi_encoder/calldata/blocks/set.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import * as _ from 'lodash';
-
-import { CalldataBlock } from '../calldata_block';
-
-export class SetCalldataBlock extends CalldataBlock {
-    private _header: Buffer | undefined;
-    private _members: CalldataBlock[];
-
-    constructor(name: string, signature: string, parentName: string) {
-        super(name, signature, parentName, 0, 0);
-        this._members = [];
-        this._header = undefined;
-    }
-
-    public getRawData(): Buffer {
-        const rawDataComponents: Buffer[] = [];
-        if (!_.isUndefined(this._header)) {
-            rawDataComponents.push(this._header);
-        }
-        _.each(this._members, (member: CalldataBlock) => {
-            const memberBuffer = member.getRawData();
-            rawDataComponents.push(memberBuffer);
-        });
-        const rawData = Buffer.concat(rawDataComponents);
-        return rawData;
-    }
-
-    public setMembers(members: CalldataBlock[]): void {
-        this._members = members;
-    }
-
-    public setHeader(header: Buffer): void {
-        this._setHeaderSize(header.byteLength);
-        this._header = header;
-    }
-
-    public toBuffer(): Buffer {
-        if (!_.isUndefined(this._header)) {
-            return this._header;
-        }
-        return new Buffer('');
-    }
-
-    public getMembers(): CalldataBlock[] {
-        return this._members;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/calldata.ts b/packages/utils/src/abi_encoder/calldata/calldata.ts
deleted file mode 100644
index b08fb71ce..000000000
--- a/packages/utils/src/abi_encoder/calldata/calldata.ts
+++ /dev/null
@@ -1,245 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { constants } from '../utils/constants';
-import { EncodingRules } from '../utils/rules';
-
-import { PointerCalldataBlock } from './blocks/pointer';
-import { SetCalldataBlock } from './blocks/set';
-import { CalldataBlock } from './calldata_block';
-import { CalldataIterator, ReverseCalldataIterator } from './iterator';
-
-export class Calldata {
-    private readonly _rules: EncodingRules;
-    private _selector: string;
-    private _root: CalldataBlock | undefined;
-
-    public constructor(rules: EncodingRules) {
-        this._rules = rules;
-        this._selector = '';
-        this._root = undefined;
-    }
-    /**
-     * Sets the root calldata block. This block usually corresponds to a Method.
-     */
-    public setRoot(block: CalldataBlock): void {
-        this._root = block;
-    }
-    /**
-     * Sets the selector to be prepended onto the calldata.
-     * If the root block was created by a Method then a selector will likely be set.
-     */
-    public setSelector(selector: string): void {
-        if (!_.startsWith(selector, '0x')) {
-            throw new Error(`Expected selector to be hex. Missing prefix '0x'`);
-        } else if (selector.length !== constants.HEX_SELECTOR_LENGTH_IN_CHARS) {
-            throw new Error(`Invalid selector '${selector}'`);
-        }
-        this._selector = selector;
-    }
-    /**
-     * Iterates through the calldata blocks, starting from the root block, to construct calldata as a hex string.
-     * If the `optimize` flag is set then this calldata will be condensed, to save gas.
-     * If the `annotate` flag is set then this will return human-readable calldata.
-     * If the `annotate` flag is *not* set then this will return EVM-compatible calldata.
-     */
-    public toString(): string {
-        // Sanity check: root block must be set
-        if (_.isUndefined(this._root)) {
-            throw new Error('expected root');
-        }
-        // Optimize, if flag set
-        if (this._rules.shouldOptimize) {
-            this._optimize();
-        }
-        // Set offsets
-        const iterator = new CalldataIterator(this._root);
-        let offset = 0;
-        for (const block of iterator) {
-            block.setOffset(offset);
-            offset += block.getSizeInBytes();
-        }
-        // Generate hex string
-        const hexString = this._rules.shouldAnnotate
-            ? this._toHumanReadableCallData()
-            : this._toEvmCompatibeCallDataHex();
-        return hexString;
-    }
-    /**
-     * There are three types of calldata blocks: Blob, Set and Pointer.
-     * Scenarios arise where distinct pointers resolve to identical values.
-     * We optimize by keeping only one such instance of the identical value, and redirecting all pointers here.
-     * We keep the last such duplicate value because pointers can only be positive (they cannot point backwards).
-     *
-     * Example #1:
-     *  function f(string[], string[])
-     *  f(["foo", "bar", "blitz"], ["foo", "bar", "blitz"])
-     *  The array ["foo", "bar", "blitz"] will only be included in the calldata once.
-     *
-     * Example #2:
-     *  function f(string[], string)
-     *  f(["foo", "bar", "blitz"], "foo")
-     *  The string "foo" will only be included in the calldata once.
-     *
-     * Example #3:
-     *  function f((string, uint, bytes), string, uint, bytes)
-     *  f(("foo", 5, "0x05"), "foo", 5, "0x05")
-     *  The string "foo" and bytes "0x05" will only be included in the calldata once.
-     *  The duplicate `uint 5` values cannot be optimized out because they are static values (no pointer points to them).
-     *
-     * @TODO #1:
-     *   This optimization strategy handles blocks that are exact duplicates of one another.
-     *   But what if some block is a combination of two other blocks? Or a subset of another block?
-     *   This optimization problem is not much different from the current implemetation.
-     *   Instead of tracking "observed" hashes, at each node we would simply do pattern-matching on the calldata.
-     *   This strategy would be applied after assigning offsets to the tree, rather than before (as in this strategy).
-     *   Note that one consequence of this strategy is pointers may resolve to offsets that are not word-aligned.
-     *   This shouldn't be a problem but further investigation should be done.
-     *
-     * @TODO #2:
-     *   To be done as a follow-up to @TODO #1.
-     *   Since we optimize from the bottom-up, we could be affecting the outcome of a later potential optimization.
-     *   For example, what if by removing one duplicate value we miss out on optimizing another block higher in the tree.
-     *   To handle this case, at each node we can store a candidate optimization in a priority queue (sorted by calldata size).
-     *   At the end of traversing the tree, the candidate at the front of the queue will be the most optimal output.
-     *
-     */
-    private _optimize(): void {
-        // Step 1/1 Create a reverse iterator (starts from the end of the calldata to the beginning)
-        if (_.isUndefined(this._root)) {
-            throw new Error('expected root');
-        }
-        const iterator = new ReverseCalldataIterator(this._root);
-        // Step 2/2 Iterate over each block, keeping track of which blocks have been seen and pruning redundant blocks.
-        const blocksByHash: { [key: string]: CalldataBlock } = {};
-        for (const block of iterator) {
-            // If a block is a pointer and its value has already been observed, then update
-            // the pointer to resolve to the existing value.
-            if (block instanceof PointerCalldataBlock) {
-                const dependencyBlockHashBuf = block.getDependency().computeHash();
-                const dependencyBlockHash = ethUtil.bufferToHex(dependencyBlockHashBuf);
-                if (dependencyBlockHash in blocksByHash) {
-                    const blockWithSameHash = blocksByHash[dependencyBlockHash];
-                    if (blockWithSameHash !== block.getDependency()) {
-                        block.setAlias(blockWithSameHash);
-                    }
-                }
-                continue;
-            }
-            // This block has not been seen. Record its hash.
-            const blockHashBuf = block.computeHash();
-            const blockHash = ethUtil.bufferToHex(blockHashBuf);
-            if (!(blockHash in blocksByHash)) {
-                blocksByHash[blockHash] = block;
-            }
-        }
-    }
-    private _toEvmCompatibeCallDataHex(): string {
-        // Sanity check: must have a root block.
-        if (_.isUndefined(this._root)) {
-            throw new Error('expected root');
-        }
-        // Construct an array of buffers (one buffer for each block).
-        const selectorBuffer = ethUtil.toBuffer(this._selector);
-        const valueBufs: Buffer[] = [selectorBuffer];
-        const iterator = new CalldataIterator(this._root);
-        for (const block of iterator) {
-            valueBufs.push(block.toBuffer());
-        }
-        // Create hex from buffer array.
-        const combinedBuffers = Buffer.concat(valueBufs);
-        const hexValue = ethUtil.bufferToHex(combinedBuffers);
-        return hexValue;
-    }
-    /**
-     * Returns human-readable calldata.
-     *
-     * Example:
-     *   simpleFunction(string[], string[])
-     *   strings = ["Hello", "World"]
-     *   simpleFunction(strings, strings)
-     *
-     * Output:
-     *   0xbb4f12e3
-     *                                                                                      ### simpleFunction
-     *   0x0       0000000000000000000000000000000000000000000000000000000000000040              ptr<array1> (alias for array2)
-     *   0x20      0000000000000000000000000000000000000000000000000000000000000040              ptr<array2>
-     *
-     *   0x40      0000000000000000000000000000000000000000000000000000000000000002          ### array2
-     *   0x60      0000000000000000000000000000000000000000000000000000000000000040              ptr<array2[0]>
-     *   0x80      0000000000000000000000000000000000000000000000000000000000000080              ptr<array2[1]>
-     *   0xa0      0000000000000000000000000000000000000000000000000000000000000005              array2[0]
-     *   0xc0      48656c6c6f000000000000000000000000000000000000000000000000000000
-     *   0xe0      0000000000000000000000000000000000000000000000000000000000000005              array2[1]
-     *   0x100     576f726c64000000000000000000000000000000000000000000000000000000
-     */
-    private _toHumanReadableCallData(): string {
-        // Sanity check: must have a root block.
-        if (_.isUndefined(this._root)) {
-            throw new Error('expected root');
-        }
-        // Constants for constructing annotated string
-        const offsetPadding = 10;
-        const valuePadding = 74;
-        const namePadding = 80;
-        const evmWordStartIndex = 0;
-        const emptySize = 0;
-        // Construct annotated calldata
-        let hexValue = `${this._selector}`;
-        let offset = 0;
-        const functionName: string = this._root.getName();
-        const iterator = new CalldataIterator(this._root);
-        for (const block of iterator) {
-            // Process each block 1 word at a time
-            const size = block.getSizeInBytes();
-            const name = block.getName();
-            const parentName = block.getParentName();
-            const prettyName = name.replace(`${parentName}.`, '').replace(`${functionName}.`, '');
-            // Resulting line will be <offsetStr><valueStr><nameStr>
-            let offsetStr = '';
-            let valueStr = '';
-            let nameStr = '';
-            let lineStr = '';
-            if (size === emptySize) {
-                // This is a Set block with no header.
-                // For example, a tuple or an array with a defined length.
-                offsetStr = ' '.repeat(offsetPadding);
-                valueStr = ' '.repeat(valuePadding);
-                nameStr = `### ${prettyName.padEnd(namePadding)}`;
-                lineStr = `\n${offsetStr}${valueStr}${nameStr}`;
-            } else {
-                // This block has at least one word of value.
-                offsetStr = `0x${offset.toString(constants.HEX_BASE)}`.padEnd(offsetPadding);
-                valueStr = ethUtil
-                    .stripHexPrefix(
-                        ethUtil.bufferToHex(
-                            block.toBuffer().slice(evmWordStartIndex, constants.EVM_WORD_WIDTH_IN_BYTES),
-                        ),
-                    )
-                    .padEnd(valuePadding);
-                if (block instanceof SetCalldataBlock) {
-                    nameStr = `### ${prettyName.padEnd(namePadding)}`;
-                    lineStr = `\n${offsetStr}${valueStr}${nameStr}`;
-                } else {
-                    nameStr = `    ${prettyName.padEnd(namePadding)}`;
-                    lineStr = `${offsetStr}${valueStr}${nameStr}`;
-                }
-            }
-            // This block has a value that is more than 1 word.
-            for (let j = constants.EVM_WORD_WIDTH_IN_BYTES; j < size; j += constants.EVM_WORD_WIDTH_IN_BYTES) {
-                offsetStr = `0x${(offset + j).toString(constants.HEX_BASE)}`.padEnd(offsetPadding);
-                valueStr = ethUtil
-                    .stripHexPrefix(
-                        ethUtil.bufferToHex(block.toBuffer().slice(j, j + constants.EVM_WORD_WIDTH_IN_BYTES)),
-                    )
-                    .padEnd(valuePadding);
-                nameStr = ' '.repeat(namePadding);
-                lineStr = `${lineStr}\n${offsetStr}${valueStr}${nameStr}`;
-            }
-            // Append to hex value
-            hexValue = `${hexValue}\n${lineStr}`;
-            offset += size;
-        }
-        return hexValue;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/calldata_block.ts b/packages/utils/src/abi_encoder/calldata/calldata_block.ts
deleted file mode 100644
index 35bd994e5..000000000
--- a/packages/utils/src/abi_encoder/calldata/calldata_block.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-
-export abstract class CalldataBlock {
-    private readonly _signature: string;
-    private readonly _parentName: string;
-    private _name: string;
-    private _offsetInBytes: number;
-    private _headerSizeInBytes: number;
-    private _bodySizeInBytes: number;
-
-    constructor(
-        name: string,
-        signature: string,
-        parentName: string,
-        headerSizeInBytes: number,
-        bodySizeInBytes: number,
-    ) {
-        this._name = name;
-        this._signature = signature;
-        this._parentName = parentName;
-        this._offsetInBytes = 0;
-        this._headerSizeInBytes = headerSizeInBytes;
-        this._bodySizeInBytes = bodySizeInBytes;
-    }
-
-    protected _setHeaderSize(headerSizeInBytes: number): void {
-        this._headerSizeInBytes = headerSizeInBytes;
-    }
-
-    protected _setBodySize(bodySizeInBytes: number): void {
-        this._bodySizeInBytes = bodySizeInBytes;
-    }
-
-    protected _setName(name: string): void {
-        this._name = name;
-    }
-
-    public getName(): string {
-        return this._name;
-    }
-
-    public getParentName(): string {
-        return this._parentName;
-    }
-
-    public getSignature(): string {
-        return this._signature;
-    }
-    public getHeaderSizeInBytes(): number {
-        return this._headerSizeInBytes;
-    }
-
-    public getBodySizeInBytes(): number {
-        return this._bodySizeInBytes;
-    }
-
-    public getSizeInBytes(): number {
-        return this.getHeaderSizeInBytes() + this.getBodySizeInBytes();
-    }
-
-    public getOffsetInBytes(): number {
-        return this._offsetInBytes;
-    }
-
-    public setOffset(offsetInBytes: number): void {
-        this._offsetInBytes = offsetInBytes;
-    }
-
-    public computeHash(): Buffer {
-        const rawData = this.getRawData();
-        const hash = ethUtil.sha3(rawData);
-        return hash;
-    }
-
-    public abstract toBuffer(): Buffer;
-    public abstract getRawData(): Buffer;
-}
diff --git a/packages/utils/src/abi_encoder/calldata/iterator.ts b/packages/utils/src/abi_encoder/calldata/iterator.ts
deleted file mode 100644
index 333b32b4f..000000000
--- a/packages/utils/src/abi_encoder/calldata/iterator.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-/* tslint:disable max-classes-per-file */
-import * as _ from 'lodash';
-
-import { Queue } from '../utils/queue';
-
-import { BlobCalldataBlock } from './blocks/blob';
-import { PointerCalldataBlock } from './blocks/pointer';
-import { SetCalldataBlock } from './blocks/set';
-import { CalldataBlock } from './calldata_block';
-
-/**
- * Iterator class for Calldata Blocks. Blocks follows the order
- * they should be put into calldata that is passed to he EVM.
- *
- * Example #1:
- * Let root = Set {
- *                  Blob{} A,
- *                  Pointer {
- *                      Blob{} a
- *                  } B,
- *                  Blob{} C
- *            }
- * It will iterate as follows: [A, B, C, B.a]
- *
- * Example #2:
- * Let root = Set {
- *                  Blob{} A,
- *                  Pointer {
- *                      Blob{} a
- *                      Pointer {
- *                          Blob{} b
- *                      }
- *                  } B,
- *                  Pointer {
- *                      Blob{} c
- *                  } C
- *            }
- * It will iterate as follows: [A, B, C, B.a, B.b, C.c]
- */
-abstract class BaseIterator implements Iterable<CalldataBlock> {
-    protected readonly _root: CalldataBlock;
-    protected readonly _queue: Queue<CalldataBlock>;
-
-    private static _createQueue(block: CalldataBlock): Queue<CalldataBlock> {
-        const queue = new Queue<CalldataBlock>();
-        // Base case
-        if (!(block instanceof SetCalldataBlock)) {
-            queue.pushBack(block);
-            return queue;
-        }
-        // This is a set; add members
-        const set = block;
-        _.eachRight(set.getMembers(), (member: CalldataBlock) => {
-            queue.mergeFront(BaseIterator._createQueue(member));
-        });
-        // Add children
-        _.each(set.getMembers(), (member: CalldataBlock) => {
-            // Traverse child if it is a unique pointer.
-            // A pointer that is an alias for another pointer is ignored.
-            if (member instanceof PointerCalldataBlock && _.isUndefined(member.getAlias())) {
-                const dependency = member.getDependency();
-                queue.mergeBack(BaseIterator._createQueue(dependency));
-            }
-        });
-        // Put set block at the front of the queue
-        queue.pushFront(set);
-        return queue;
-    }
-
-    public constructor(root: CalldataBlock) {
-        this._root = root;
-        this._queue = BaseIterator._createQueue(root);
-    }
-
-    public [Symbol.iterator](): { next: () => IteratorResult<CalldataBlock> } {
-        return {
-            next: () => {
-                const nextBlock = this.nextBlock();
-                if (!_.isUndefined(nextBlock)) {
-                    return {
-                        value: nextBlock,
-                        done: false,
-                    };
-                }
-                return {
-                    done: true,
-                    value: new BlobCalldataBlock('', '', '', new Buffer('')),
-                };
-            },
-        };
-    }
-
-    public abstract nextBlock(): CalldataBlock | undefined;
-}
-
-export class CalldataIterator extends BaseIterator {
-    public constructor(root: CalldataBlock) {
-        super(root);
-    }
-
-    public nextBlock(): CalldataBlock | undefined {
-        return this._queue.popFront();
-    }
-}
-
-export class ReverseCalldataIterator extends BaseIterator {
-    public constructor(root: CalldataBlock) {
-        super(root);
-    }
-
-    public nextBlock(): CalldataBlock | undefined {
-        return this._queue.popBack();
-    }
-}
diff --git a/packages/utils/src/abi_encoder/calldata/raw_calldata.ts b/packages/utils/src/abi_encoder/calldata/raw_calldata.ts
deleted file mode 100644
index 189841989..000000000
--- a/packages/utils/src/abi_encoder/calldata/raw_calldata.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { constants } from '../utils/constants';
-import { Queue } from '../utils/queue';
-
-export class RawCalldata {
-    private static readonly _INITIAL_OFFSET = 0;
-    private readonly _value: Buffer;
-    private readonly _selector: string;
-    private readonly _scopes: Queue<number>;
-    private _offset: number;
-
-    public constructor(value: string | Buffer, hasSelector: boolean = true) {
-        // Sanity check
-        if (typeof value === 'string' && !_.startsWith(value, '0x')) {
-            throw new Error(`Expected raw calldata to start with '0x'`);
-        }
-        // Construct initial values
-        this._value = ethUtil.toBuffer(value);
-        this._selector = '0x';
-        this._scopes = new Queue<number>();
-        this._scopes.pushBack(RawCalldata._INITIAL_OFFSET);
-        this._offset = RawCalldata._INITIAL_OFFSET;
-        // If there's a selector then slice it
-        if (hasSelector) {
-            const selectorBuf = this._value.slice(constants.HEX_SELECTOR_LENGTH_IN_BYTES);
-            this._value = this._value.slice(constants.HEX_SELECTOR_LENGTH_IN_BYTES);
-            this._selector = ethUtil.bufferToHex(selectorBuf);
-        }
-    }
-
-    public popBytes(lengthInBytes: number): Buffer {
-        const value = this._value.slice(this._offset, this._offset + lengthInBytes);
-        this.setOffset(this._offset + lengthInBytes);
-        return value;
-    }
-
-    public popWord(): Buffer {
-        const wordInBytes = 32;
-        return this.popBytes(wordInBytes);
-    }
-
-    public popWords(length: number): Buffer {
-        const wordInBytes = 32;
-        return this.popBytes(length * wordInBytes);
-    }
-
-    public readBytes(from: number, to: number): Buffer {
-        const value = this._value.slice(from, to);
-        return value;
-    }
-
-    public setOffset(offsetInBytes: number): void {
-        this._offset = offsetInBytes;
-    }
-
-    public startScope(): void {
-        this._scopes.pushFront(this._offset);
-    }
-
-    public endScope(): void {
-        this._scopes.popFront();
-    }
-
-    public getOffset(): number {
-        return this._offset;
-    }
-
-    public toAbsoluteOffset(relativeOffset: number): number {
-        const scopeOffset = this._scopes.peekFront();
-        if (_.isUndefined(scopeOffset)) {
-            throw new Error(`Tried to access undefined scope.`);
-        }
-        const absoluteOffset = relativeOffset + scopeOffset;
-        return absoluteOffset;
-    }
-
-    public getSelector(): string {
-        return this._selector;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_type_factory.ts b/packages/utils/src/abi_encoder/evm_data_type_factory.ts
deleted file mode 100644
index 268649148..000000000
--- a/packages/utils/src/abi_encoder/evm_data_type_factory.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-/* tslint:disable max-classes-per-file */
-import { DataItem, MethodAbi } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { generateDataItemsFromSignature } from './utils/signature_parser';
-
-import { DataType } from './abstract_data_types/data_type';
-import { DataTypeFactory } from './abstract_data_types/interfaces';
-import { AddressDataType } from './evm_data_types/address';
-import { ArrayDataType } from './evm_data_types/array';
-import { BoolDataType } from './evm_data_types/bool';
-import { DynamicBytesDataType } from './evm_data_types/dynamic_bytes';
-import { IntDataType } from './evm_data_types/int';
-import { MethodDataType } from './evm_data_types/method';
-import { PointerDataType } from './evm_data_types/pointer';
-import { StaticBytesDataType } from './evm_data_types/static_bytes';
-import { StringDataType } from './evm_data_types/string';
-import { TupleDataType } from './evm_data_types/tuple';
-import { UIntDataType } from './evm_data_types/uint';
-
-export class Address extends AddressDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Bool extends BoolDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Int extends IntDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class UInt extends UIntDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class StaticBytes extends StaticBytesDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class DynamicBytes extends DynamicBytesDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class String extends StringDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Pointer extends PointerDataType {
-    public constructor(destDataType: DataType, parentDataType: DataType) {
-        super(destDataType, parentDataType, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Tuple extends TupleDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Array extends ArrayDataType {
-    public constructor(dataItem: DataItem) {
-        super(dataItem, EvmDataTypeFactory.getInstance());
-    }
-}
-
-export class Method extends MethodDataType {
-    public constructor(abi: MethodAbi) {
-        super(abi, EvmDataTypeFactory.getInstance());
-    }
-}
-
-/* tslint:disable no-construct */
-export class EvmDataTypeFactory implements DataTypeFactory {
-    private static _instance: DataTypeFactory;
-
-    public static getInstance(): DataTypeFactory {
-        if (!EvmDataTypeFactory._instance) {
-            EvmDataTypeFactory._instance = new EvmDataTypeFactory();
-        }
-        return EvmDataTypeFactory._instance;
-    }
-
-    /* tslint:disable prefer-function-over-method */
-    public create(dataItem: DataItem, parentDataType?: DataType): DataType {
-        // Create data type
-        let dataType: undefined | DataType;
-        if (Array.matchType(dataItem.type)) {
-            dataType = new Array(dataItem);
-        } else if (Address.matchType(dataItem.type)) {
-            dataType = new Address(dataItem);
-        } else if (Bool.matchType(dataItem.type)) {
-            dataType = new Bool(dataItem);
-        } else if (Int.matchType(dataItem.type)) {
-            dataType = new Int(dataItem);
-        } else if (UInt.matchType(dataItem.type)) {
-            dataType = new UInt(dataItem);
-        } else if (StaticBytes.matchType(dataItem.type)) {
-            dataType = new StaticBytes(dataItem);
-        } else if (Tuple.matchType(dataItem.type)) {
-            dataType = new Tuple(dataItem);
-        } else if (DynamicBytes.matchType(dataItem.type)) {
-            dataType = new DynamicBytes(dataItem);
-        } else if (String.matchType(dataItem.type)) {
-            dataType = new String(dataItem);
-        }
-        // @TODO: DataTypeement Fixed/UFixed types
-        if (_.isUndefined(dataType)) {
-            throw new Error(`Unrecognized data type: '${dataItem.type}'`);
-        } else if (!_.isUndefined(parentDataType) && !dataType.isStatic()) {
-            const pointerToDataType = new Pointer(dataType, parentDataType);
-            return pointerToDataType;
-        }
-        return dataType;
-    }
-    /* tslint:enable prefer-function-over-method */
-
-    private constructor() {}
-}
-
-/**
- * Convenience function for creating a DataType from different inputs.
- * @param input A single or set of DataItem or a DataType signature.
- *              A signature in the form of '<type>' is interpreted as a `DataItem`
- *              For example, 'string' is interpreted as {type: 'string'}
- *              A signature in the form '(<type1>, <type2>, ..., <typen>)' is interpreted as `DataItem[]`
- *              For eaxmple, '(string, uint256)' is interpreted as [{type: 'string'}, {type: 'uint256'}]
- * @return DataType corresponding to input.
- */
-export function create(input: DataItem | DataItem[] | string): DataType {
-    // Handle different types of input
-    const isSignature = typeof input === 'string';
-    const isTupleSignature = isSignature && (input as string).startsWith('(');
-    const shouldParseAsTuple = isTupleSignature || _.isArray(input);
-    // Create input `dataItem`
-    let dataItem: DataItem;
-    if (shouldParseAsTuple) {
-        const dataItems = isSignature ? generateDataItemsFromSignature(input as string) : (input as DataItem[]);
-        dataItem = {
-            name: '',
-            type: 'tuple',
-            components: dataItems,
-        };
-    } else {
-        dataItem = isSignature ? generateDataItemsFromSignature(input as string)[0] : (input as DataItem);
-    }
-    // Create data type
-    const dataType = EvmDataTypeFactory.getInstance().create(dataItem);
-    return dataType;
-}
-/* tslint:enable no-construct */
diff --git a/packages/utils/src/abi_encoder/evm_data_types/address.ts b/packages/utils/src/abi_encoder/evm_data_types/address.ts
deleted file mode 100644
index 2278830eb..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/address.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-
-export class AddressDataType extends AbstractBlobDataType {
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = true;
-    private static readonly _ADDRESS_SIZE_IN_BYTES = 20;
-    private static readonly _DECODED_ADDRESS_OFFSET_IN_BYTES =
-        constants.EVM_WORD_WIDTH_IN_BYTES - AddressDataType._ADDRESS_SIZE_IN_BYTES;
-
-    public static matchType(type: string): boolean {
-        return type === SolidityTypes.Address;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, AddressDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!AddressDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Address with bad input: ${dataItem}`);
-        }
-    }
-
-    // Disable prefer-function-over-method for inherited abstract methods.
-    /* tslint:disable prefer-function-over-method */
-    public encodeValue(value: string): Buffer {
-        if (!ethUtil.isValidAddress(value)) {
-            throw new Error(`Invalid address: '${value}'`);
-        }
-        const valueBuf = ethUtil.toBuffer(value);
-        const encodedValueBuf = ethUtil.setLengthLeft(valueBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-        return encodedValueBuf;
-    }
-
-    public decodeValue(calldata: RawCalldata): string {
-        const valueBufPadded = calldata.popWord();
-        const valueBuf = valueBufPadded.slice(AddressDataType._DECODED_ADDRESS_OFFSET_IN_BYTES);
-        const value = ethUtil.bufferToHex(valueBuf);
-        const valueLowercase = _.toLower(value);
-        return valueLowercase;
-    }
-
-    public getSignatureType(): string {
-        return SolidityTypes.Address;
-    }
-    /* tslint:enable prefer-function-over-method */
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/array.ts b/packages/utils/src/abi_encoder/evm_data_types/array.ts
deleted file mode 100644
index d9607f47e..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/array.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { DataItem } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractSetDataType } from '../abstract_data_types/types/set';
-import { constants } from '../utils/constants';
-
-export class ArrayDataType extends AbstractSetDataType {
-    private static readonly _MATCHER = RegExp('^(.+)\\[([0-9]*)\\]$');
-    private readonly _elementType: string;
-
-    public static matchType(type: string): boolean {
-        return ArrayDataType._MATCHER.test(type);
-    }
-
-    private static _decodeElementTypeAndLengthFromType(type: string): [string, undefined | number] {
-        const matches = ArrayDataType._MATCHER.exec(type);
-        if (_.isNull(matches) || matches.length !== 3) {
-            throw new Error(`Could not parse array: ${type}`);
-        } else if (_.isUndefined(matches[1])) {
-            throw new Error(`Could not parse array type: ${type}`);
-        } else if (_.isUndefined(matches[2])) {
-            throw new Error(`Could not parse array length: ${type}`);
-        }
-        const arrayElementType = matches[1];
-        const arrayLength = _.isEmpty(matches[2]) ? undefined : parseInt(matches[2], constants.DEC_BASE);
-        return [arrayElementType, arrayLength];
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        // Construct parent
-        const isArray = true;
-        const [arrayElementType, arrayLength] = ArrayDataType._decodeElementTypeAndLengthFromType(dataItem.type);
-        super(dataItem, dataTypeFactory, isArray, arrayLength, arrayElementType);
-        // Set array properties
-        this._elementType = arrayElementType;
-    }
-
-    public getSignatureType(): string {
-        return this._computeSignature(false);
-    }
-
-    public getSignature(isDetailed?: boolean): string {
-        if (_.isEmpty(this.getDataItem().name) || !isDetailed) {
-            return this.getSignatureType();
-        }
-        const name = this.getDataItem().name;
-        const lastIndexOfScopeDelimiter = name.lastIndexOf('.');
-        const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0;
-        const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name;
-        const detailedSignature = `${shortName} ${this._computeSignature(isDetailed)}`;
-        return detailedSignature;
-    }
-
-    private _computeSignature(isDetailed?: boolean): string {
-        // Compute signature for a single array element
-        const elementDataItem: DataItem = {
-            type: this._elementType,
-            name: '',
-        };
-        const elementComponents = this.getDataItem().components;
-        if (!_.isUndefined(elementComponents)) {
-            elementDataItem.components = elementComponents;
-        }
-        const elementDataType = this.getFactory().create(elementDataItem);
-        const elementSignature = elementDataType.getSignature(isDetailed);
-        // Construct signature for array of type `element`
-        if (_.isUndefined(this._arrayLength)) {
-            return `${elementSignature}[]`;
-        } else {
-            return `${elementSignature}[${this._arrayLength}]`;
-        }
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/bool.ts b/packages/utils/src/abi_encoder/evm_data_types/bool.ts
deleted file mode 100644
index 23298bc88..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/bool.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { BigNumber } from '../../configured_bignumber';
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-
-export class BoolDataType extends AbstractBlobDataType {
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = true;
-
-    public static matchType(type: string): boolean {
-        return type === SolidityTypes.Bool;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, BoolDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!BoolDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Bool with bad input: ${dataItem}`);
-        }
-    }
-
-    // Disable prefer-function-over-method for inherited abstract methods.
-    /* tslint:disable prefer-function-over-method */
-    public encodeValue(value: boolean): Buffer {
-        const encodedValue = value ? '0x1' : '0x0';
-        const encodedValueBuf = ethUtil.setLengthLeft(
-            ethUtil.toBuffer(encodedValue),
-            constants.EVM_WORD_WIDTH_IN_BYTES,
-        );
-        return encodedValueBuf;
-    }
-
-    public decodeValue(calldata: RawCalldata): boolean {
-        const valueBuf = calldata.popWord();
-        const valueHex = ethUtil.bufferToHex(valueBuf);
-        const valueNumber = new BigNumber(valueHex, constants.HEX_BASE);
-        if (!(valueNumber.isEqualTo(0) || valueNumber.isEqualTo(1))) {
-            throw new Error(`Failed to decode boolean. Expected 0x0 or 0x1, got ${valueHex}`);
-        }
-        /* tslint:disable boolean-naming */
-        const value: boolean = !valueNumber.isEqualTo(0);
-        /* tslint:enable boolean-naming */
-        return value;
-    }
-
-    public getSignatureType(): string {
-        return SolidityTypes.Bool;
-    }
-    /* tslint:enable prefer-function-over-method */
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/dynamic_bytes.ts b/packages/utils/src/abi_encoder/evm_data_types/dynamic_bytes.ts
deleted file mode 100644
index fa38b63c0..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/dynamic_bytes.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-
-export class DynamicBytesDataType extends AbstractBlobDataType {
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = false;
-
-    public static matchType(type: string): boolean {
-        return type === SolidityTypes.Bytes;
-    }
-
-    private static _sanityCheckValue(value: string | Buffer): void {
-        if (typeof value !== 'string') {
-            return;
-        }
-        if (!_.startsWith(value, '0x')) {
-            throw new Error(`Tried to encode non-hex value. Value must inlcude '0x' prefix.`);
-        } else if (value.length % 2 !== 0) {
-            throw new Error(`Tried to assign ${value}, which is contains a half-byte. Use full bytes only.`);
-        }
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, DynamicBytesDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!DynamicBytesDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Dynamic Bytes with bad input: ${dataItem}`);
-        }
-    }
-
-    // Disable prefer-function-over-method for inherited abstract methods.
-    /* tslint:disable prefer-function-over-method */
-    public encodeValue(value: string | Buffer): Buffer {
-        // Encoded value is of the form: <length><value>, with each field padded to be word-aligned.
-        // 1/3 Construct the length
-        const valueBuf = ethUtil.toBuffer(value);
-        const wordsToStoreValuePadded = Math.ceil(valueBuf.byteLength / constants.EVM_WORD_WIDTH_IN_BYTES);
-        const bytesToStoreValuePadded = wordsToStoreValuePadded * constants.EVM_WORD_WIDTH_IN_BYTES;
-        const lengthBuf = ethUtil.toBuffer(valueBuf.byteLength);
-        const lengthBufPadded = ethUtil.setLengthLeft(lengthBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-        // 2/3 Construct the value
-        DynamicBytesDataType._sanityCheckValue(value);
-        const valueBufPadded = ethUtil.setLengthRight(valueBuf, bytesToStoreValuePadded);
-        // 3/3 Combine length and value
-        const encodedValue = Buffer.concat([lengthBufPadded, valueBufPadded]);
-        return encodedValue;
-    }
-
-    public decodeValue(calldata: RawCalldata): string {
-        // Encoded value is of the form: <length><value>, with each field padded to be word-aligned.
-        // 1/2 Decode length
-        const lengthBuf = calldata.popWord();
-        const lengthHex = ethUtil.bufferToHex(lengthBuf);
-        const length = parseInt(lengthHex, constants.HEX_BASE);
-        // 2/2 Decode value
-        const wordsToStoreValuePadded = Math.ceil(length / constants.EVM_WORD_WIDTH_IN_BYTES);
-        const valueBufPadded = calldata.popWords(wordsToStoreValuePadded);
-        const valueBuf = valueBufPadded.slice(0, length);
-        const value = ethUtil.bufferToHex(valueBuf);
-        DynamicBytesDataType._sanityCheckValue(value);
-        return value;
-    }
-
-    public getSignatureType(): string {
-        return SolidityTypes.Bytes;
-    }
-    /* tslint:enable prefer-function-over-method */
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/int.ts b/packages/utils/src/abi_encoder/evm_data_types/int.ts
deleted file mode 100644
index f8be1f778..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/int.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { BigNumber } from '../../configured_bignumber';
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-import * as EncoderMath from '../utils/math';
-
-export class IntDataType extends AbstractBlobDataType {
-    private static readonly _MATCHER = RegExp(
-        '^int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256){0,1}$',
-    );
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = true;
-    private static readonly _MAX_WIDTH: number = 256;
-    private static readonly _DEFAULT_WIDTH: number = IntDataType._MAX_WIDTH;
-    private readonly _width: number;
-    private readonly _minValue: BigNumber;
-    private readonly _maxValue: BigNumber;
-
-    public static matchType(type: string): boolean {
-        return IntDataType._MATCHER.test(type);
-    }
-
-    private static _decodeWidthFromType(type: string): number {
-        const matches = IntDataType._MATCHER.exec(type);
-        const width =
-            !_.isNull(matches) && matches.length === 2 && !_.isUndefined(matches[1])
-                ? parseInt(matches[1], constants.DEC_BASE)
-                : IntDataType._DEFAULT_WIDTH;
-        return width;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, IntDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!IntDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Int with bad input: ${dataItem}`);
-        }
-        this._width = IntDataType._decodeWidthFromType(dataItem.type);
-        this._minValue = new BigNumber(2).exponentiatedBy(this._width - 1).times(-1);
-        this._maxValue = new BigNumber(2).exponentiatedBy(this._width - 1).minus(1);
-    }
-
-    public encodeValue(value: BigNumber | string | number): Buffer {
-        const encodedValue = EncoderMath.safeEncodeNumericValue(value, this._minValue, this._maxValue);
-        return encodedValue;
-    }
-
-    public decodeValue(calldata: RawCalldata): BigNumber | number {
-        const valueBuf = calldata.popWord();
-        const value = EncoderMath.safeDecodeNumericValue(valueBuf, this._minValue, this._maxValue);
-        const numberOfBytesInUint8 = 8;
-        if (this._width === numberOfBytesInUint8) {
-            return value.toNumber();
-        }
-        return value;
-    }
-
-    public getSignatureType(): string {
-        return `${SolidityTypes.Int}${this._width}`;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/method.ts b/packages/utils/src/abi_encoder/evm_data_types/method.ts
deleted file mode 100644
index c852a0fdf..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/method.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { DataItem, MethodAbi } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { DataType } from '../abstract_data_types/data_type';
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractSetDataType } from '../abstract_data_types/types/set';
-import { constants } from '../utils/constants';
-import { DecodingRules, EncodingRules } from '../utils/rules';
-
-import { TupleDataType } from './tuple';
-
-export class MethodDataType extends AbstractSetDataType {
-    private readonly _methodSignature: string;
-    private readonly _methodSelector: string;
-    private readonly _returnDataType: DataType;
-
-    public constructor(abi: MethodAbi, dataTypeFactory: DataTypeFactory) {
-        const methodDataItem = { type: 'method', name: abi.name, components: abi.inputs };
-        super(methodDataItem, dataTypeFactory);
-        this._methodSignature = this._computeSignature();
-        this._methodSelector = this._computeSelector();
-        const returnDataItem: DataItem = { type: 'tuple', name: abi.name, components: abi.outputs };
-        this._returnDataType = new TupleDataType(returnDataItem, this.getFactory());
-    }
-
-    public encode(value: any, rules?: EncodingRules): string {
-        const calldata = super.encode(value, rules, this._methodSelector);
-        return calldata;
-    }
-
-    public decode(calldata: string, rules?: DecodingRules): any[] | object {
-        const value = super.decode(calldata, rules, this._methodSelector);
-        return value;
-    }
-
-    public encodeReturnValues(value: any, rules?: EncodingRules): string {
-        const returnData = this._returnDataType.encode(value, rules);
-        return returnData;
-    }
-
-    public decodeReturnValues(returndata: string, rules?: DecodingRules): any {
-        const returnValues = this._returnDataType.decode(returndata, rules);
-        return returnValues;
-    }
-
-    public strictDecodeReturnValue<T>(returndata: string, rules?: DecodingRules): T {
-        const returnValues = this._returnDataType.decode(returndata, rules);
-        const returnValuesAsArray: any = _.isObject(returnValues) ? _.values(returnValues) : [returnValues];
-        switch (returnValuesAsArray.length) {
-            case 0:
-                return undefined as any;
-            case 1:
-                return returnValuesAsArray[0];
-            default:
-                return returnValuesAsArray;
-        }
-    }
-
-    public getSignatureType(): string {
-        return this._methodSignature;
-    }
-
-    public getSelector(): string {
-        return this._methodSelector;
-    }
-
-    private _computeSignature(): string {
-        const memberSignature = this._computeSignatureOfMembers();
-        const methodSignature = `${this.getDataItem().name}${memberSignature}`;
-        return methodSignature;
-    }
-
-    private _computeSelector(): string {
-        const signature = this._computeSignature();
-        const selector = ethUtil.bufferToHex(
-            ethUtil.toBuffer(
-                ethUtil
-                    .sha3(signature)
-                    .slice(constants.HEX_SELECTOR_BYTE_OFFSET_IN_CALLDATA, constants.HEX_SELECTOR_LENGTH_IN_BYTES),
-            ),
-        );
-        return selector;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/pointer.ts b/packages/utils/src/abi_encoder/evm_data_types/pointer.ts
deleted file mode 100644
index 250db7c64..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/pointer.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { DataItem } from 'ethereum-types';
-
-import { DataType } from '../abstract_data_types/data_type';
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractPointerDataType } from '../abstract_data_types/types/pointer';
-
-export class PointerDataType extends AbstractPointerDataType {
-    constructor(destDataType: DataType, parentDataType: DataType, dataTypeFactory: DataTypeFactory) {
-        const destDataItem = destDataType.getDataItem();
-        const dataItem: DataItem = { name: `ptr<${destDataItem.name}>`, type: `ptr<${destDataItem.type}>` };
-        super(dataItem, dataTypeFactory, destDataType, parentDataType);
-    }
-
-    public getSignatureType(): string {
-        return this._destination.getSignature(false);
-    }
-
-    public getSignature(isDetailed?: boolean): string {
-        return this._destination.getSignature(isDetailed);
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/static_bytes.ts b/packages/utils/src/abi_encoder/evm_data_types/static_bytes.ts
deleted file mode 100644
index cbf1957d7..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/static_bytes.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-
-export class StaticBytesDataType extends AbstractBlobDataType {
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = true;
-    private static readonly _MATCHER = RegExp(
-        '^(byte|bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32))$',
-    );
-    private static readonly _DEFAULT_WIDTH = 1;
-    private readonly _width: number;
-
-    public static matchType(type: string): boolean {
-        return StaticBytesDataType._MATCHER.test(type);
-    }
-
-    private static _decodeWidthFromType(type: string): number {
-        const matches = StaticBytesDataType._MATCHER.exec(type);
-        const width =
-            !_.isNull(matches) && matches.length === 3 && !_.isUndefined(matches[2])
-                ? parseInt(matches[2], constants.DEC_BASE)
-                : StaticBytesDataType._DEFAULT_WIDTH;
-        return width;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, StaticBytesDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!StaticBytesDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Static Bytes with bad input: ${dataItem}`);
-        }
-        this._width = StaticBytesDataType._decodeWidthFromType(dataItem.type);
-    }
-
-    public getSignatureType(): string {
-        // Note that `byte` reduces to `bytes1`
-        return `${SolidityTypes.Bytes}${this._width}`;
-    }
-
-    public encodeValue(value: string | Buffer): Buffer {
-        // 1/2 Convert value into a buffer and do bounds checking
-        this._sanityCheckValue(value);
-        const valueBuf = ethUtil.toBuffer(value);
-        // 2/2 Store value as hex
-        const valuePadded = ethUtil.setLengthRight(valueBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-        return valuePadded;
-    }
-
-    public decodeValue(calldata: RawCalldata): string {
-        const valueBufPadded = calldata.popWord();
-        const valueBuf = valueBufPadded.slice(0, this._width);
-        const value = ethUtil.bufferToHex(valueBuf);
-        this._sanityCheckValue(value);
-        return value;
-    }
-
-    private _sanityCheckValue(value: string | Buffer): void {
-        if (typeof value === 'string') {
-            if (!_.startsWith(value, '0x')) {
-                throw new Error(`Tried to encode non-hex value. Value must inlcude '0x' prefix.`);
-            } else if (value.length % 2 !== 0) {
-                throw new Error(`Tried to assign ${value}, which is contains a half-byte. Use full bytes only.`);
-            }
-        }
-        const valueBuf = ethUtil.toBuffer(value);
-        if (valueBuf.byteLength > this._width) {
-            throw new Error(
-                `Tried to assign ${value} (${
-                    valueBuf.byteLength
-                } bytes), which exceeds max bytes that can be stored in a ${this.getSignature()}`,
-            );
-        }
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/string.ts b/packages/utils/src/abi_encoder/evm_data_types/string.ts
deleted file mode 100644
index 97ac46442..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/string.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-
-export class StringDataType extends AbstractBlobDataType {
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = false;
-
-    public static matchType(type: string): boolean {
-        return type === SolidityTypes.String;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, StringDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!StringDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate String with bad input: ${dataItem}`);
-        }
-    }
-
-    // Disable prefer-function-over-method for inherited abstract methods.
-    /* tslint:disable prefer-function-over-method */
-    public encodeValue(value: string): Buffer {
-        // Encoded value is of the form: <length><value>, with each field padded to be word-aligned.
-        // 1/3 Construct the length
-        const wordsToStoreValuePadded = Math.ceil(value.length / constants.EVM_WORD_WIDTH_IN_BYTES);
-        const bytesToStoreValuePadded = wordsToStoreValuePadded * constants.EVM_WORD_WIDTH_IN_BYTES;
-        const lengthBuf = ethUtil.toBuffer(value.length);
-        const lengthBufPadded = ethUtil.setLengthLeft(lengthBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-        // 2/3 Construct the value
-        const valueBuf = new Buffer(value);
-        const valueBufPadded = ethUtil.setLengthRight(valueBuf, bytesToStoreValuePadded);
-        // 3/3 Combine length and value
-        const encodedValue = Buffer.concat([lengthBufPadded, valueBufPadded]);
-        return encodedValue;
-    }
-
-    public decodeValue(calldata: RawCalldata): string {
-        // Encoded value is of the form: <length><value>, with each field padded to be word-aligned.
-        // 1/2 Decode length
-        const lengthBufPadded = calldata.popWord();
-        const lengthHexPadded = ethUtil.bufferToHex(lengthBufPadded);
-        const length = parseInt(lengthHexPadded, constants.HEX_BASE);
-        // 2/2 Decode value
-        const wordsToStoreValuePadded = Math.ceil(length / constants.EVM_WORD_WIDTH_IN_BYTES);
-        const valueBufPadded = calldata.popWords(wordsToStoreValuePadded);
-        const valueBuf = valueBufPadded.slice(0, length);
-        const value = valueBuf.toString('ascii');
-        return value;
-    }
-
-    public getSignatureType(): string {
-        return SolidityTypes.String;
-    }
-    /* tslint:enable prefer-function-over-method */
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/tuple.ts b/packages/utils/src/abi_encoder/evm_data_types/tuple.ts
deleted file mode 100644
index 5000c85e8..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/tuple.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractSetDataType } from '../abstract_data_types/types/set';
-
-export class TupleDataType extends AbstractSetDataType {
-    public static matchType(type: string): boolean {
-        return type === SolidityTypes.Tuple;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory);
-        if (!TupleDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate Tuple with bad input: ${dataItem}`);
-        }
-    }
-
-    public getSignatureType(): string {
-        return this._computeSignatureOfMembers(false);
-    }
-
-    public getSignature(isDetailed?: boolean): string {
-        if (_.isEmpty(this.getDataItem().name) || !isDetailed) {
-            return this.getSignatureType();
-        }
-        const name = this.getDataItem().name;
-        const lastIndexOfScopeDelimiter = name.lastIndexOf('.');
-        const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0;
-        const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name;
-        const detailedSignature = `${shortName} ${this._computeSignatureOfMembers(isDetailed)}`;
-        return detailedSignature;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/evm_data_types/uint.ts b/packages/utils/src/abi_encoder/evm_data_types/uint.ts
deleted file mode 100644
index a82aa789e..000000000
--- a/packages/utils/src/abi_encoder/evm_data_types/uint.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { DataItem, SolidityTypes } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { BigNumber } from '../../configured_bignumber';
-import { DataTypeFactory } from '../abstract_data_types/interfaces';
-import { AbstractBlobDataType } from '../abstract_data_types/types/blob';
-import { RawCalldata } from '../calldata/raw_calldata';
-import { constants } from '../utils/constants';
-import * as EncoderMath from '../utils/math';
-
-export class UIntDataType extends AbstractBlobDataType {
-    private static readonly _MATCHER = RegExp(
-        '^uint(8|16|24|32|40|48|56|64|72|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256){0,1}$',
-    );
-    private static readonly _SIZE_KNOWN_AT_COMPILE_TIME: boolean = true;
-    private static readonly _MAX_WIDTH: number = 256;
-    private static readonly _DEFAULT_WIDTH: number = UIntDataType._MAX_WIDTH;
-    private static readonly _MIN_VALUE = new BigNumber(0);
-    private readonly _width: number;
-    private readonly _maxValue: BigNumber;
-
-    public static matchType(type: string): boolean {
-        return UIntDataType._MATCHER.test(type);
-    }
-
-    private static _decodeWidthFromType(type: string): number {
-        const matches = UIntDataType._MATCHER.exec(type);
-        const width =
-            !_.isNull(matches) && matches.length === 2 && !_.isUndefined(matches[1])
-                ? parseInt(matches[1], constants.DEC_BASE)
-                : UIntDataType._DEFAULT_WIDTH;
-        return width;
-    }
-
-    public constructor(dataItem: DataItem, dataTypeFactory: DataTypeFactory) {
-        super(dataItem, dataTypeFactory, UIntDataType._SIZE_KNOWN_AT_COMPILE_TIME);
-        if (!UIntDataType.matchType(dataItem.type)) {
-            throw new Error(`Tried to instantiate UInt with bad input: ${dataItem}`);
-        }
-        this._width = UIntDataType._decodeWidthFromType(dataItem.type);
-        this._maxValue = new BigNumber(2).exponentiatedBy(this._width).minus(1);
-    }
-
-    public encodeValue(value: BigNumber | string | number): Buffer {
-        const encodedValue = EncoderMath.safeEncodeNumericValue(value, UIntDataType._MIN_VALUE, this._maxValue);
-        return encodedValue;
-    }
-
-    public decodeValue(calldata: RawCalldata): BigNumber | number {
-        const valueBuf = calldata.popWord();
-        const value = EncoderMath.safeDecodeNumericValue(valueBuf, UIntDataType._MIN_VALUE, this._maxValue);
-        const numberOfBytesInUint8 = 8;
-        if (this._width === numberOfBytesInUint8) {
-            return value.toNumber();
-        }
-        return value;
-    }
-
-    public getSignatureType(): string {
-        return `${SolidityTypes.Uint}${this._width}`;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/index.ts b/packages/utils/src/abi_encoder/index.ts
deleted file mode 100644
index cfacfe075..000000000
--- a/packages/utils/src/abi_encoder/index.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-export { EncodingRules, DecodingRules } from './utils/rules';
-export {
-    Address,
-    Array,
-    Bool,
-    DynamicBytes,
-    Int,
-    Method,
-    Pointer,
-    StaticBytes,
-    String,
-    Tuple,
-    UInt,
-    create,
-} from './evm_data_type_factory';
-export { DataType } from './abstract_data_types/data_type';
diff --git a/packages/utils/src/abi_encoder/utils/constants.ts b/packages/utils/src/abi_encoder/utils/constants.ts
deleted file mode 100644
index fc586f295..000000000
--- a/packages/utils/src/abi_encoder/utils/constants.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { DecodingRules, EncodingRules } from './rules';
-
-export const constants = {
-    EVM_WORD_WIDTH_IN_BYTES: 32,
-    EVM_WORD_WIDTH_IN_BITS: 256,
-    HEX_BASE: 16,
-    DEC_BASE: 10,
-    BIN_BASE: 2,
-    HEX_SELECTOR_LENGTH_IN_CHARS: 10,
-    HEX_SELECTOR_LENGTH_IN_BYTES: 4,
-    HEX_SELECTOR_BYTE_OFFSET_IN_CALLDATA: 0,
-    // Disable no-object-literal-type-assertion so we can enforce cast
-    /* tslint:disable no-object-literal-type-assertion */
-    DEFAULT_DECODING_RULES: { shouldConvertStructsToObjects: true } as DecodingRules,
-    DEFAULT_ENCODING_RULES: { shouldOptimize: true, shouldAnnotate: false } as EncodingRules,
-    /* tslint:enable no-object-literal-type-assertion */
-};
diff --git a/packages/utils/src/abi_encoder/utils/math.ts b/packages/utils/src/abi_encoder/utils/math.ts
deleted file mode 100644
index a2a79e2a8..000000000
--- a/packages/utils/src/abi_encoder/utils/math.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { BigNumber } from '../../configured_bignumber';
-import { constants } from '../utils/constants';
-
-function sanityCheckBigNumberRange(
-    value_: BigNumber | string | number,
-    minValue: BigNumber,
-    maxValue: BigNumber,
-): void {
-    const value = new BigNumber(value_, 10);
-    if (value.isGreaterThan(maxValue)) {
-        throw new Error(`Tried to assign value of ${value}, which exceeds max value of ${maxValue}`);
-    } else if (value.isLessThan(minValue)) {
-        throw new Error(`Tried to assign value of ${value}, which exceeds min value of ${minValue}`);
-    } else if (value.isNaN()) {
-        throw new Error(`Tried to assign NaN value`);
-    }
-}
-function bigNumberToPaddedBuffer(value: BigNumber): Buffer {
-    const valueHex = `0x${value.toString(constants.HEX_BASE)}`;
-    const valueBuf = ethUtil.toBuffer(valueHex);
-    const valueBufPadded = ethUtil.setLengthLeft(valueBuf, constants.EVM_WORD_WIDTH_IN_BYTES);
-    return valueBufPadded;
-}
-/**
- * Takes a numeric value and returns its ABI-encoded value
- * @param value_    The value to encode.
- * @return ABI Encoded value
- */
-export function encodeNumericValue(value_: BigNumber | string | number): Buffer {
-    const value = new BigNumber(value_, 10);
-    // Case 1/2: value is non-negative
-    if (value.isGreaterThanOrEqualTo(0)) {
-        const encodedPositiveValue = bigNumberToPaddedBuffer(value);
-        return encodedPositiveValue;
-    }
-    // Case 2/2: Value is negative
-    // Use two's-complement to encode the value
-    // Step 1/3: Convert negative value to positive binary string
-    const valueBin = value.times(-1).toString(constants.BIN_BASE);
-    // Step 2/3: Invert binary value
-    let invertedValueBin = '1'.repeat(constants.EVM_WORD_WIDTH_IN_BITS - valueBin.length);
-    _.each(valueBin, (bit: string) => {
-        invertedValueBin += bit === '1' ? '0' : '1';
-    });
-    const invertedValue = new BigNumber(invertedValueBin, constants.BIN_BASE);
-    // Step 3/3: Add 1 to inverted value
-    const negativeValue = invertedValue.plus(1);
-    const encodedValue = bigNumberToPaddedBuffer(negativeValue);
-    return encodedValue;
-}
-/**
- * Takes a numeric value and returns its ABI-encoded value.
- * Performs an additional sanity check, given the min/max allowed value.
- * @param value_    The value to encode.
- * @return ABI Encoded value
- */
-export function safeEncodeNumericValue(
-    value: BigNumber | string | number,
-    minValue: BigNumber,
-    maxValue: BigNumber,
-): Buffer {
-    sanityCheckBigNumberRange(value, minValue, maxValue);
-    const encodedValue = encodeNumericValue(value);
-    return encodedValue;
-}
-/**
- * Takes an ABI-encoded numeric value and returns its decoded value as a BigNumber.
- * @param encodedValue    The encoded numeric value.
- * @param minValue        The minimum possible decoded value.
- * @return ABI Decoded value
- */
-export function decodeNumericValue(encodedValue: Buffer, minValue: BigNumber): BigNumber {
-    const valueHex = ethUtil.bufferToHex(encodedValue);
-    // Case 1/3: value is definitely non-negative because of numeric boundaries
-    const value = new BigNumber(valueHex, constants.HEX_BASE);
-    if (!minValue.isLessThan(0)) {
-        return value;
-    }
-    // Case 2/3: value is non-negative because there is no leading 1 (encoded as two's-complement)
-    const valueBin = value.toString(constants.BIN_BASE);
-    const isValueNegative = valueBin.length === constants.EVM_WORD_WIDTH_IN_BITS && _.startsWith(valueBin[0], '1');
-    if (!isValueNegative) {
-        return value;
-    }
-    // Case 3/3: value is negative
-    // Step 1/3: Invert b inary value
-    let invertedValueBin = '';
-    _.each(valueBin, (bit: string) => {
-        invertedValueBin += bit === '1' ? '0' : '1';
-    });
-    const invertedValue = new BigNumber(invertedValueBin, constants.BIN_BASE);
-    // Step 2/3: Add 1 to inverted value
-    // The result is the two's-complement representation of the input value.
-    const positiveValue = invertedValue.plus(1);
-    // Step 3/3: Invert positive value to get the negative value
-    const negativeValue = positiveValue.times(-1);
-    return negativeValue;
-}
-/**
- * Takes an ABI-encoded numeric value and returns its decoded value as a BigNumber.
- * Performs an additional sanity check, given the min/max allowed value.
- * @param encodedValue    The encoded numeric value.
- * @param minValue        The minimum possible decoded value.
- * @return ABI Decoded value
- */
-export function safeDecodeNumericValue(encodedValue: Buffer, minValue: BigNumber, maxValue: BigNumber): BigNumber {
-    const value = decodeNumericValue(encodedValue, minValue);
-    sanityCheckBigNumberRange(value, minValue, maxValue);
-    return value;
-}
diff --git a/packages/utils/src/abi_encoder/utils/queue.ts b/packages/utils/src/abi_encoder/utils/queue.ts
deleted file mode 100644
index 53afb7e11..000000000
--- a/packages/utils/src/abi_encoder/utils/queue.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-export class Queue<T> {
-    private _store: T[] = [];
-
-    public pushBack(val: T): void {
-        this._store.push(val);
-    }
-
-    public pushFront(val: T): void {
-        this._store.unshift(val);
-    }
-
-    public popFront(): T | undefined {
-        return this._store.shift();
-    }
-
-    public popBack(): T | undefined {
-        if (this._store.length === 0) {
-            return undefined;
-        }
-        const backElement = this._store.splice(-1, 1)[0];
-        return backElement;
-    }
-
-    public mergeBack(q: Queue<T>): void {
-        this._store = this._store.concat(q._store);
-    }
-
-    public mergeFront(q: Queue<T>): void {
-        this._store = q._store.concat(this._store);
-    }
-
-    public getStore(): T[] {
-        return this._store;
-    }
-
-    public peekFront(): T | undefined {
-        return this._store.length >= 0 ? this._store[0] : undefined;
-    }
-}
diff --git a/packages/utils/src/abi_encoder/utils/rules.ts b/packages/utils/src/abi_encoder/utils/rules.ts
deleted file mode 100644
index c8d83c3ba..000000000
--- a/packages/utils/src/abi_encoder/utils/rules.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export interface DecodingRules {
-    shouldConvertStructsToObjects: boolean;
-}
-
-export interface EncodingRules {
-    shouldOptimize?: boolean;
-    shouldAnnotate?: boolean;
-}
diff --git a/packages/utils/src/abi_encoder/utils/signature_parser.ts b/packages/utils/src/abi_encoder/utils/signature_parser.ts
deleted file mode 100644
index 315784cea..000000000
--- a/packages/utils/src/abi_encoder/utils/signature_parser.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import { DataItem } from 'ethereum-types';
-import * as _ from 'lodash';
-
-/**
- * Returns an array of DataItem's corresponding to the input signature.
- * A signature can be in two forms: '<DataItem.type>' or '(<DataItem1.type>, <DataItem2.type>, ...)
- * An example of the first form would be 'address' or 'uint256'
- * An example of the second form would be '(address, uint256)'
- * Signatures can also include a name field, for example: 'foo address' or '(foo address, bar uint256)'
- * @param signature of input DataItems
- * @return DataItems derived from input signature
- */
-export function generateDataItemsFromSignature(signature: string): DataItem[] {
-    let trimmedSignature = signature;
-    if (signature.startsWith('(')) {
-        if (!signature.endsWith(')')) {
-            throw new Error(`Failed to generate data item. Must end with ')'`);
-        }
-        trimmedSignature = signature.substr(1, signature.length - 2);
-    }
-    trimmedSignature += ',';
-    let isCurrTokenArray = false;
-    let currTokenArrayModifier = '';
-    let isParsingArrayModifier = false;
-    let currToken = '';
-    let parenCount = 0;
-    let currTokenName = '';
-    const dataItems: DataItem[] = [];
-    for (const char of trimmedSignature) {
-        // Tokenize the type string while keeping track of parentheses.
-        switch (char) {
-            case '(':
-                parenCount += 1;
-                currToken += char;
-                break;
-            case ')':
-                parenCount -= 1;
-                currToken += char;
-                break;
-            case '[':
-                if (parenCount === 0) {
-                    isParsingArrayModifier = true;
-                    isCurrTokenArray = true;
-                    currTokenArrayModifier += '[';
-                } else {
-                    currToken += char;
-                }
-                break;
-            case ']':
-                if (parenCount === 0) {
-                    isParsingArrayModifier = false;
-                    currTokenArrayModifier += ']';
-                } else {
-                    currToken += char;
-                }
-                break;
-            case ' ':
-                if (parenCount === 0) {
-                    currTokenName = currToken;
-                    currToken = '';
-                } else {
-                    currToken += char;
-                }
-                break;
-            case ',':
-                if (parenCount === 0) {
-                    // Generate new DataItem from token
-                    const components = currToken.startsWith('(') ? generateDataItemsFromSignature(currToken) : [];
-                    const isTuple = !_.isEmpty(components);
-                    const dataItem: DataItem = { name: currTokenName, type: '' };
-                    if (isTuple) {
-                        dataItem.type = 'tuple';
-                        dataItem.components = components;
-                    } else {
-                        dataItem.type = currToken;
-                    }
-                    if (isCurrTokenArray) {
-                        dataItem.type += currTokenArrayModifier;
-                    }
-                    dataItems.push(dataItem);
-                    // reset token state
-                    currTokenName = '';
-                    currToken = '';
-                    isCurrTokenArray = false;
-                    currTokenArrayModifier = '';
-                    break;
-                } else {
-                    currToken += char;
-                    break;
-                }
-            default:
-                if (isParsingArrayModifier) {
-                    currTokenArrayModifier += char;
-                } else {
-                    currToken += char;
-                }
-                break;
-        }
-    }
-    return dataItems;
-}
diff --git a/packages/utils/src/abi_utils.ts b/packages/utils/src/abi_utils.ts
deleted file mode 100644
index 3e6fc9665..000000000
--- a/packages/utils/src/abi_utils.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-import { AbiDefinition, AbiType, ContractAbi, DataItem, MethodAbi } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { BigNumber } from './configured_bignumber';
-
-type ParamName = null | string | NestedParamName;
-interface NestedParamName {
-    name: string | null;
-    names: ParamName[];
-}
-
-// Note(albrow): This function is unexported in ethers.js. Copying it here for
-// now.
-// Source: https://github.com/ethers-io/ethers.js/blob/884593ab76004a808bf8097e9753fb5f8dcc3067/contracts/interface.js#L30
-function parseEthersParams(params: DataItem[]): { names: ParamName[]; types: string[] } {
-    const names: ParamName[] = [];
-    const types: string[] = [];
-
-    params.forEach((param: DataItem) => {
-        if (param.components != null) {
-            let suffix = '';
-            const arrayBracket = param.type.indexOf('[');
-            if (arrayBracket >= 0) {
-                suffix = param.type.substring(arrayBracket);
-            }
-
-            const result = parseEthersParams(param.components);
-            names.push({ name: param.name || null, names: result.names });
-            types.push(`tuple(${result.types.join(',')})${suffix}`);
-        } else {
-            names.push(param.name || null);
-            types.push(param.type);
-        }
-    });
-
-    return {
-        names,
-        types,
-    };
-}
-
-// returns true if x is equal to y and false otherwise. Performs some minimal
-// type conversion and data massaging for x and y, depending on type. name and
-// type should typically be derived from parseEthersParams.
-function isAbiDataEqual(name: ParamName, type: string, x: any, y: any): boolean {
-    if (_.isUndefined(x) && _.isUndefined(y)) {
-        return true;
-    } else if (_.isUndefined(x) && !_.isUndefined(y)) {
-        return false;
-    } else if (!_.isUndefined(x) && _.isUndefined(y)) {
-        return false;
-    }
-    if (_.endsWith(type, '[]')) {
-        // For array types, we iterate through the elements and check each one
-        // individually. Strangely, name does not need to be changed in this
-        // case.
-        if (x.length !== y.length) {
-            return false;
-        }
-        const newType = _.trimEnd(type, '[]');
-        for (let i = 0; i < x.length; i++) {
-            if (!isAbiDataEqual(name, newType, x[i], y[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (_.startsWith(type, 'tuple(')) {
-        if (_.isString(name)) {
-            throw new Error('Internal error: type was tuple but names was a string');
-        } else if (_.isNull(name)) {
-            throw new Error('Internal error: type was tuple but names was null');
-        }
-        // For tuples, we iterate through the underlying values and check each
-        // one individually.
-        const types = splitTupleTypes(type);
-        if (types.length !== name.names.length) {
-            throw new Error(
-                `Internal error: parameter types/names length mismatch (${types.length} != ${name.names.length})`,
-            );
-        }
-        for (let i = 0; i < types.length; i++) {
-            // For tuples, name is an object with a names property that is an
-            // array. As an example, for orders, name looks like:
-            //
-            //  {
-            //      name: 'orders',
-            //      names: [
-            //          'makerAddress',
-            //          // ...
-            //          'takerAssetData'
-            //      ]
-            //  }
-            //
-            const nestedName = _.isString(name.names[i])
-                ? (name.names[i] as string)
-                : ((name.names[i] as NestedParamName).name as string);
-            if (!isAbiDataEqual(name.names[i], types[i], x[nestedName], y[nestedName])) {
-                return false;
-            }
-        }
-        return true;
-    } else if (type === 'address' || type === 'bytes') {
-        // HACK(albrow): ethers.js returns the checksummed address even when
-        // initially passed in a non-checksummed address. To account for that,
-        // we convert to lowercase before comparing.
-        return _.isEqual(_.toLower(x), _.toLower(y));
-    } else if (_.startsWith(type, 'uint') || _.startsWith(type, 'int')) {
-        return new BigNumber(x).eq(new BigNumber(y));
-    }
-    return _.isEqual(x, y);
-}
-
-// splitTupleTypes splits a tuple type string (of the form `tuple(X)` where X is
-// any other type or list of types) into its component types. It works with
-// nested tuples, so, e.g., `tuple(tuple(uint256,address),bytes32)` will yield:
-// `['tuple(uint256,address)', 'bytes32']`. It expects exactly one tuple type as
-// an argument (not an array).
-function splitTupleTypes(type: string): string[] {
-    if (_.endsWith(type, '[]')) {
-        throw new Error('Internal error: array types are not supported');
-    } else if (!_.startsWith(type, 'tuple(')) {
-        throw new Error(`Internal error: expected tuple type but got non-tuple type: ${type}`);
-    }
-    // Trim the outtermost tuple().
-    const trimmedType = type.substring('tuple('.length, type.length - 1);
-    const types: string[] = [];
-    let currToken = '';
-    let parenCount = 0;
-    // Tokenize the type string while keeping track of parentheses.
-    for (const char of trimmedType) {
-        switch (char) {
-            case '(':
-                parenCount += 1;
-                currToken += char;
-                break;
-            case ')':
-                parenCount -= 1;
-                currToken += char;
-                break;
-            case ',':
-                if (parenCount === 0) {
-                    types.push(currToken);
-                    currToken = '';
-                    break;
-                } else {
-                    currToken += char;
-                    break;
-                }
-            default:
-                currToken += char;
-                break;
-        }
-    }
-    types.push(currToken);
-    return types;
-}
-
-export const abiUtils = {
-    parseEthersParams,
-    isAbiDataEqual,
-    splitTupleTypes,
-    parseFunctionParam(param: DataItem): string {
-        if (param.type === 'tuple') {
-            // Parse out tuple types into {type_1, type_2, ..., type_N}
-            const tupleComponents = param.components;
-            const paramString = _.map(tupleComponents, component => abiUtils.parseFunctionParam(component));
-            const tupleParamString = `{${paramString}}`;
-            return tupleParamString;
-        }
-        return param.type;
-    },
-    getFunctionSignature(methodAbi: MethodAbi): string {
-        const functionName = methodAbi.name;
-        const parameterTypeList = _.map(methodAbi.inputs, (param: DataItem) => abiUtils.parseFunctionParam(param));
-        const functionSignature = `${functionName}(${parameterTypeList})`;
-        return functionSignature;
-    },
-    /**
-     * Solidity supports function overloading whereas TypeScript does not.
-     * See: https://solidity.readthedocs.io/en/v0.4.21/contracts.html?highlight=overload#function-overloading
-     * In order to support overloaded functions, we suffix overloaded function names with an index.
-     * This index should be deterministic, regardless of function ordering within the smart contract. To do so,
-     * we assign indexes based on the alphabetical order of function signatures.
-     *
-     * E.g
-     * ['f(uint)', 'f(uint,byte32)']
-     * Should always be renamed to:
-     * ['f1(uint)', 'f2(uint,byte32)']
-     * Regardless of the order in which these these overloaded functions are declared within the contract ABI.
-     */
-    renameOverloadedMethods(inputContractAbi: ContractAbi): ContractAbi {
-        const contractAbi = _.cloneDeep(inputContractAbi);
-        const methodAbis = contractAbi.filter((abi: AbiDefinition) => abi.type === AbiType.Function) as MethodAbi[];
-        // Sort method Abis into alphabetical order, by function signature
-        const methodAbisOrdered = _.sortBy(methodAbis, [
-            (methodAbi: MethodAbi) => {
-                const functionSignature = abiUtils.getFunctionSignature(methodAbi);
-                return functionSignature;
-            },
-        ]);
-        // Group method Abis by name (overloaded methods will be grouped together, in alphabetical order)
-        const methodAbisByName: { [key: string]: MethodAbi[] } = {};
-        _.each(methodAbisOrdered, methodAbi => {
-            (methodAbisByName[methodAbi.name] || (methodAbisByName[methodAbi.name] = [])).push(methodAbi);
-        });
-        // Rename overloaded methods to overloadedMethodName1, overloadedMethodName2, ...
-        _.each(methodAbisByName, methodAbisWithSameName => {
-            _.each(methodAbisWithSameName, (methodAbi, i: number) => {
-                if (methodAbisWithSameName.length > 1) {
-                    const overloadedMethodId = i + 1;
-                    const sanitizedMethodName = `${methodAbi.name}${overloadedMethodId}`;
-                    const indexOfExistingAbiWithSanitizedMethodNameIfExists = _.findIndex(
-                        methodAbis,
-                        currentMethodAbi => currentMethodAbi.name === sanitizedMethodName,
-                    );
-                    if (indexOfExistingAbiWithSanitizedMethodNameIfExists >= 0) {
-                        const methodName = methodAbi.name;
-                        throw new Error(
-                            `Failed to rename overloaded method '${methodName}' to '${sanitizedMethodName}'. A method with this name already exists.`,
-                        );
-                    }
-                    methodAbi.name = sanitizedMethodName;
-                }
-            });
-        });
-        return contractAbi;
-    },
-};
diff --git a/packages/utils/src/address_utils.ts b/packages/utils/src/address_utils.ts
deleted file mode 100644
index 1fc960408..000000000
--- a/packages/utils/src/address_utils.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { addHexPrefix, stripHexPrefix } from 'ethereumjs-util';
-import * as jsSHA3 from 'js-sha3';
-import * as _ from 'lodash';
-
-const BASIC_ADDRESS_REGEX = /^(0x)?[0-9a-f]{40}$/i;
-const SAME_CASE_ADDRESS_REGEX = /^(0x)?([0-9a-f]{40}|[0-9A-F]{40})$/;
-const ADDRESS_LENGTH = 40;
-
-export const addressUtils = {
-    isChecksumAddress(address: string): boolean {
-        // Check each case
-        const unprefixedAddress = address.replace('0x', '');
-        const addressHash = jsSHA3.keccak256(unprefixedAddress.toLowerCase());
-
-        for (let i = 0; i < ADDRESS_LENGTH; i++) {
-            // The nth letter should be uppercase if the nth digit of casemap is 1
-            const hexBase = 16;
-            const lowercaseRange = 7;
-            if (
-                (parseInt(addressHash[i], hexBase) > lowercaseRange &&
-                    unprefixedAddress[i].toUpperCase() !== unprefixedAddress[i]) ||
-                (parseInt(addressHash[i], hexBase) <= lowercaseRange &&
-                    unprefixedAddress[i].toLowerCase() !== unprefixedAddress[i])
-            ) {
-                return false;
-            }
-        }
-        return true;
-    },
-    isAddress(address: string): boolean {
-        if (!BASIC_ADDRESS_REGEX.test(address)) {
-            // Check if it has the basic requirements of an address
-            return false;
-        } else if (SAME_CASE_ADDRESS_REGEX.test(address)) {
-            // If it's all small caps or all all caps, return true
-            return true;
-        } else {
-            // Otherwise check each case
-            const isValidChecksummedAddress = addressUtils.isChecksumAddress(address);
-            return isValidChecksummedAddress;
-        }
-    },
-    padZeros(address: string): string {
-        return addHexPrefix(_.padStart(stripHexPrefix(address), ADDRESS_LENGTH, '0'));
-    },
-};
diff --git a/packages/utils/src/class_utils.ts b/packages/utils/src/class_utils.ts
deleted file mode 100644
index 04e60ee57..000000000
--- a/packages/utils/src/class_utils.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import * as _ from 'lodash';
-
-export const classUtils = {
-    // This is useful for classes that have nested methods. Nested methods don't get bound out of the box.
-    bindAll(self: any, exclude: string[] = ['contructor'], thisArg?: any): void {
-        for (const key of Object.getOwnPropertyNames(self)) {
-            const val = self[key];
-            if (!_.includes(exclude, key)) {
-                if (_.isFunction(val)) {
-                    self[key] = val.bind(thisArg || self);
-                } else if (_.isObject(val)) {
-                    classUtils.bindAll(val, exclude, self);
-                }
-            }
-        }
-        return self;
-    },
-};
diff --git a/packages/utils/src/configured_bignumber.ts b/packages/utils/src/configured_bignumber.ts
deleted file mode 100644
index 34b57d303..000000000
--- a/packages/utils/src/configured_bignumber.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { BigNumber } from 'bignumber.js';
-
-BigNumber.config({
-    // By default BigNumber's `toString` method converts to exponential notation if the value has
-    // more then 20 digits. We want to avoid this behavior, so we set EXPONENTIAL_AT to a high number
-    EXPONENTIAL_AT: 1000,
-    // Note(albrow): This is the lowest value for which
-    // `x.div(y).floor() === x.divToInt(y)`
-    // for all values of x and y <= MAX_UINT256, where MAX_UINT256 is the
-    // maximum number represented by the uint256 type in Solidity (2^256-1).
-    DECIMAL_PLACES: 78,
-});
-
-// Set a debug print function for NodeJS
-// Upstream issue: https://github.com/MikeMcl/bignumber.js/issues/188
-import isNode = require('detect-node');
-if (isNode) {
-    // Dynamically load a NodeJS specific module.
-    // Typescript requires all imports to be global, so we need to use
-    // `const` here and disable the tslint warning.
-    // tslint:disable-next-line: no-var-requires
-    const util = require('util');
-
-    // Set a custom util.inspect function
-    // HACK: We add a function to the BigNumber class by assigning to the
-    //       prototype. The function name is a symbol provided by Node.
-    (BigNumber.prototype as any)[util.inspect.custom] = function(): string {
-        // HACK: When executed, `this` will refer to the BigNumber instance.
-        //       This is also why we need a function expression instead of an
-        //       arrow function, as the latter does not have a `this`.
-        // Return the readable string representation
-        // tslint:disable-next-line: no-invalid-this
-        return this.toString();
-    };
-}
-
-export { BigNumber };
diff --git a/packages/utils/src/constants.ts b/packages/utils/src/constants.ts
deleted file mode 100644
index 2894d4747..000000000
--- a/packages/utils/src/constants.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const NULL_BYTES = '0x';
diff --git a/packages/utils/src/error_utils.ts b/packages/utils/src/error_utils.ts
deleted file mode 100644
index 735d3940b..000000000
--- a/packages/utils/src/error_utils.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export const errorUtils = {
-    spawnSwitchErr(name: string, value: any): Error {
-        return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
-    },
-};
diff --git a/packages/utils/src/fetch_async.ts b/packages/utils/src/fetch_async.ts
deleted file mode 100644
index b4c85718d..000000000
--- a/packages/utils/src/fetch_async.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import isNode = require('detect-node');
-import 'isomorphic-fetch';
-// WARNING: This needs to be imported after isomorphic-fetch: https://github.com/mo/abortcontroller-polyfill#using-it-on-browsers-without-fetch
-// tslint:disable-next-line:ordered-imports
-import 'abortcontroller-polyfill/dist/abortcontroller-polyfill-only';
-
-export const fetchAsync = async (
-    endpoint: string,
-    options: RequestInit = {},
-    timeoutMs: number = 20000,
-): Promise<Response> => {
-    if (options.signal || (options as any).timeout) {
-        throw new Error(
-            'Cannot call fetchAsync with options.signal or options.timeout. To set a timeout, please use the supplied "timeoutMs" parameter.',
-        );
-    }
-    let optionsWithAbortParam;
-    if (!isNode) {
-        const controller = new AbortController();
-        const signal = controller.signal;
-        setTimeout(() => {
-            controller.abort();
-        }, timeoutMs);
-        optionsWithAbortParam = {
-            signal,
-            ...options,
-        };
-    } else {
-        // HACK: the `timeout` param only exists in `node-fetch`, and not on the `isomorphic-fetch`
-        // `RequestInit` type. Since `isomorphic-fetch` conditionally wraps `node-fetch` when the
-        // execution environment is `Node.js`, we need to cast it to `any` in that scenario.
-        optionsWithAbortParam = {
-            timeout: timeoutMs,
-            ...options,
-        } as any;
-    }
-
-    const response = await fetch(endpoint, optionsWithAbortParam);
-    return response;
-};
diff --git a/packages/utils/src/globals.d.ts b/packages/utils/src/globals.d.ts
deleted file mode 100644
index 94e63a32d..000000000
--- a/packages/utils/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/utils/src/index.ts b/packages/utils/src/index.ts
deleted file mode 100644
index 082aff6bb..000000000
--- a/packages/utils/src/index.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export { promisify } from './promisify';
-export { addressUtils } from './address_utils';
-export { classUtils } from './class_utils';
-export { intervalUtils } from './interval_utils';
-export { BigNumber } from './configured_bignumber';
-export { AbiDecoder } from './abi_decoder';
-export { logUtils } from './log_utils';
-export { abiUtils } from './abi_utils';
-export { NULL_BYTES } from './constants';
-export { errorUtils } from './error_utils';
-export { fetchAsync } from './fetch_async';
-export { signTypedDataUtils } from './sign_typed_data_utils';
-export import AbiEncoder = require('./abi_encoder');
diff --git a/packages/utils/src/interval_utils.ts b/packages/utils/src/interval_utils.ts
deleted file mode 100644
index 3d0561cd2..000000000
--- a/packages/utils/src/interval_utils.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-export const intervalUtils = {
-    setAsyncExcludingInterval(
-        fn: () => Promise<void>,
-        intervalMs: number,
-        onError: (err: Error) => void,
-    ): NodeJS.Timer {
-        let isLocked = false;
-        const intervalId = setInterval(async () => {
-            if (isLocked) {
-                return;
-            } else {
-                isLocked = true;
-                try {
-                    await fn();
-                } catch (err) {
-                    onError(err);
-                }
-                isLocked = false;
-            }
-        }, intervalMs);
-        return intervalId;
-    },
-    clearAsyncExcludingInterval(intervalId: NodeJS.Timer): void {
-        clearInterval(intervalId);
-    },
-    setInterval(fn: () => void, intervalMs: number, onError: (err: Error) => void): NodeJS.Timer {
-        const intervalId = setInterval(() => {
-            try {
-                fn();
-            } catch (err) {
-                onError(err);
-            }
-        }, intervalMs);
-        return intervalId;
-    },
-    clearInterval(intervalId: NodeJS.Timer): void {
-        clearInterval(intervalId);
-    },
-};
diff --git a/packages/utils/src/log_utils.ts b/packages/utils/src/log_utils.ts
deleted file mode 100644
index 6d9996c67..000000000
--- a/packages/utils/src/log_utils.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import chalk from 'chalk';
-
-export const logUtils = {
-    log(...args: any[]): void {
-        console.log(...args); // tslint:disable-line:no-console
-    },
-    warn(...args: any[]): void {
-        console.warn(...args); // tslint:disable-line:no-console
-    },
-    logWithTime(arg: string): void {
-        logUtils.log(`[${chalk.gray(new Date().toLocaleTimeString())}] ${arg}`);
-    },
-};
diff --git a/packages/utils/src/promisify.ts b/packages/utils/src/promisify.ts
deleted file mode 100644
index e82251a0f..000000000
--- a/packages/utils/src/promisify.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import * as _ from 'lodash';
-
-/**
- * Transforms callback-based function -- func(arg1, arg2 .. argN, callback) -- into an ES6-compatible Promise.
- * Promisify provides a default callback of the form (error, result) and rejects when `error` is not null. You can also
- * supply thisArg object as the second argument which will be passed to `apply`.
- */
-// HACK: This can't be properly typed without variadic kinds https://github.com/Microsoft/TypeScript/issues/5453
-export function promisify<T>(originalFn: (...args: any[]) => void, thisArg?: any): (...callArgs: any[]) => Promise<T> {
-    const promisifiedFunction = async (...callArgs: any[]): Promise<T> => {
-        return new Promise<T>((resolve, reject) => {
-            const callback = (err: Error | null, data?: T) => {
-                _.isNull(err) || _.isUndefined(err) ? resolve(data) : reject(err);
-            };
-            originalFn.apply(thisArg, [...callArgs, callback]);
-        });
-    };
-    return promisifiedFunction;
-}
diff --git a/packages/utils/src/sign_typed_data_utils.ts b/packages/utils/src/sign_typed_data_utils.ts
deleted file mode 100644
index adb66622d..000000000
--- a/packages/utils/src/sign_typed_data_utils.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { EIP712Object, EIP712ObjectValue, EIP712TypedData, EIP712Types } from '@0x/types';
-import * as ethUtil from 'ethereumjs-util';
-import * as ethers from 'ethers';
-import * as _ from 'lodash';
-
-import { BigNumber } from './configured_bignumber';
-
-export const signTypedDataUtils = {
-    /**
-     * Generates the EIP712 Typed Data hash for signing
-     * @param   typedData An object that conforms to the EIP712TypedData interface
-     * @return  A Buffer containing the hash of the typed data.
-     */
-    generateTypedDataHash(typedData: EIP712TypedData): Buffer {
-        return ethUtil.sha3(
-            Buffer.concat([
-                Buffer.from('1901', 'hex'),
-                signTypedDataUtils._structHash('EIP712Domain', typedData.domain, typedData.types),
-                signTypedDataUtils._structHash(typedData.primaryType, typedData.message, typedData.types),
-            ]),
-        );
-    },
-    _findDependencies(primaryType: string, types: EIP712Types, found: string[] = []): string[] {
-        if (found.includes(primaryType) || types[primaryType] === undefined) {
-            return found;
-        }
-        found.push(primaryType);
-        for (const field of types[primaryType]) {
-            for (const dep of signTypedDataUtils._findDependencies(field.type, types, found)) {
-                if (!found.includes(dep)) {
-                    found.push(dep);
-                }
-            }
-        }
-        return found;
-    },
-    _encodeType(primaryType: string, types: EIP712Types): string {
-        let deps = signTypedDataUtils._findDependencies(primaryType, types);
-        deps = deps.filter(d => d !== primaryType);
-        deps = [primaryType].concat(deps.sort());
-        let result = '';
-        for (const dep of deps) {
-            result += `${dep}(${types[dep].map(({ name, type }) => `${type} ${name}`).join(',')})`;
-        }
-        return result;
-    },
-    _encodeData(primaryType: string, data: EIP712Object, types: EIP712Types): string {
-        const encodedTypes = ['bytes32'];
-        const encodedValues: Array<Buffer | EIP712ObjectValue> = [signTypedDataUtils._typeHash(primaryType, types)];
-        for (const field of types[primaryType]) {
-            const value = data[field.name];
-            if (field.type === 'string' || field.type === 'bytes') {
-                const hashValue = ethUtil.sha3(value as string);
-                encodedTypes.push('bytes32');
-                encodedValues.push(hashValue);
-            } else if (types[field.type] !== undefined) {
-                encodedTypes.push('bytes32');
-                const hashValue = ethUtil.sha3(
-                    // tslint:disable-next-line:no-unnecessary-type-assertion
-                    signTypedDataUtils._encodeData(field.type, value as EIP712Object, types),
-                );
-                encodedValues.push(hashValue);
-            } else if (field.type.lastIndexOf(']') === field.type.length - 1) {
-                throw new Error('Arrays currently unimplemented in encodeData');
-            } else {
-                encodedTypes.push(field.type);
-                const normalizedValue = signTypedDataUtils._normalizeValue(field.type, value);
-                encodedValues.push(normalizedValue);
-            }
-        }
-        return ethers.utils.defaultAbiCoder.encode(encodedTypes, encodedValues);
-    },
-    _normalizeValue(type: string, value: any): EIP712ObjectValue {
-        const normalizedValue = type === 'uint256' && BigNumber.isBigNumber(value) ? value.toString() : value;
-        return normalizedValue;
-    },
-    _typeHash(primaryType: string, types: EIP712Types): Buffer {
-        return ethUtil.sha3(signTypedDataUtils._encodeType(primaryType, types));
-    },
-    _structHash(primaryType: string, data: EIP712Object, types: EIP712Types): Buffer {
-        return ethUtil.sha3(signTypedDataUtils._encodeData(primaryType, data, types));
-    },
-};