Refactor Builds!

4 files changed, 247 insertions, 1393 deletions

diff --git a/packages/order-utils/test/abi/data_type.ts b/packages/order-utils/test/abi/data_type.ts
index 1a4610f7c..201eb89f9 100644
--- a/packages/order-utils/test/abi/data_type.ts
+++ b/packages/order-utils/test/abi/data_type.ts
@@ -31,7 +31,7 @@ export abstract class PayloadDataType extends DataType {
         this.hasConstantSize = hasConstantSize;
     }
 
-    public generateCalldataBlocks(value: any, parentBlock?: CalldataBlock): PayloadCalldataBlock {
+    public generateCalldataBlock(value: any, parentBlock?: CalldataBlock): PayloadCalldataBlock {
         const encodedValue = this.encodeValue(value);
         const name = this.getDataItem().name;
         const signature = this.getSignature();
@@ -105,13 +105,13 @@ export abstract class MemberDataType extends DataType {
         this.isArray = isArray;
         this.arrayLength = arrayLength;
         if (isArray && arrayLength !== undefined) {
-            [this.members, this.memberMap] = MemberDataType.createMembersWithLength(dataItem, arrayLength);
+            [this.members, this.memberMap] = this.createMembersWithLength(dataItem, arrayLength);
         } else if (!isArray) {
-            [this.members, this.memberMap] = MemberDataType.createMembersWithKeys(dataItem);
+            [this.members, this.memberMap] = this.createMembersWithKeys(dataItem);
         }
     }
 
-    private static createMembersWithKeys(dataItem: DataItem): [DataType[], MemberMap] {
+    private createMembersWithKeys(dataItem: DataItem): [DataType[], MemberMap] {
         // Sanity check
         if (dataItem.components === undefined) {
             throw new Error(`Expected components`);
@@ -132,7 +132,7 @@ export abstract class MemberDataType extends DataType {
         return [members, memberMap];
     }
 
-    private static createMembersWithLength(dataItem: DataItem, length: number): [DataType[], MemberMap] {
+    private createMembersWithLength(dataItem: DataItem, length: number): [DataType[], MemberMap] {
         let members: DataType[] = [];
         let memberMap: MemberMap = {};
         const range = _.range(length);
@@ -165,7 +165,7 @@ export abstract class MemberDataType extends DataType {
 
         let members = this.members;
         if (this.arrayLength === undefined) {
-            [members,] = MemberDataType.createMembersWithLength(this.getDataItem(), value.length);
+            [members,] = this.createMembersWithLength(this.getDataItem(), value.length);
         }
 
         const methodBlock: MemberCalldataBlock = new MemberCalldataBlock(this.getDataItem().name, this.getSignature(), false);
@@ -200,7 +200,7 @@ export abstract class MemberDataType extends DataType {
     }
 
     public generateCalldataBlock(value: any[] | object, parentBlock?: CalldataBlock): MemberCalldataBlock {
-        const block = (value instanceof Array) ? this.generateCalldataBlockFromArray(value) : this.generateCalldataBlockFromObject(value, calldata);
+        const block = (value instanceof Array) ? this.generateCalldataBlockFromArray(value) : this.generateCalldataBlockFromObject(value);
         return block;
     }
 
diff --git a/packages/order-utils/test/abi/evm_data_types.ts b/packages/order-utils/test/abi/evm_data_types.ts
index 15fe4c9e3..4dffedb8d 100644
--- a/packages/order-utils/test/abi/evm_data_types.ts
+++ b/packages/order-utils/test/abi/evm_data_types.ts
@@ -8,6 +8,8 @@ import { Calldata } from './calldata';
 
 import { BigNumber } from '@0x/utils';
 
+var _ = require('lodash');
+
 export interface DataTypeStaticInterface {
     matchGrammar: (type: string) => boolean;
     encodeValue: (value: any) => Buffer;
@@ -382,10 +384,14 @@ export class Method extends MemberDataType {
     private methodSignature: string;
     private methodSelector: string;
 
+    // TMP
+    public selector: string;
+
     constructor(abi: MethodAbi) {
         super({ type: 'method', name: abi.name });
         this.methodSignature = this.computeSignature();
-        this.methodSelector = this.computeSelector();
+        this.selector = this.methodSelector = this.computeSelector();
+
     }
 
     private computeSignature(): string {
diff --git a/packages/order-utils/test/abi_encoder.ts b/packages/order-utils/test/abi_encoder.ts
deleted file mode 100644
index bcd427dee..000000000
--- a/packages/order-utils/test/abi_encoder.ts
+++ /dev/null
@@ -1,1152 +0,0 @@
-
-import * as chai from 'chai';
-import 'mocha';
-import ethUtil = require('ethereumjs-util');
-
-var _ = require('lodash');
-
-import { chaiSetup } from './utils/chai_setup';
-
-import { MethodAbi, DataItem } from 'ethereum-types';
-
-import { BigNumber } from '@0x/utils';
-import { bigNumberify } from 'ethers/utils';
-
-chaiSetup.configure();
-const expect = chai.expect;
-
-
-class Word {
-    private value: string;
-
-    constructor(value?: string) {
-        if (value === undefined) {
-            this.value = '';
-        } else {
-            this.value = value;
-        }
-    }
-
-    public set(value: string) {
-        if (value.length !== 64) {
-            throw `Tried to create word that is not 32 bytes: ${value}`;
-        }
-
-        this.value = value;
-    }
-
-    public get(): string {
-        return this.value;
-    }
-
-    public getAsHex(): string {
-        return `0x${this.value}`;
-    }
-}
-
-export enum CalldataSection {
-    NONE,
-    PARAMS,
-    DATA,
-}
-
-class Memblock {
-    private dataType: DataType;
-    private location: { calldataSection: CalldataSection; sectionOffset: BigNumber; offset: BigNumber };
-
-    constructor(dataType: DataType) {
-        this.dataType = dataType;
-        this.location = {
-            calldataSection: CalldataSection.NONE,
-            sectionOffset: new BigNumber(0),
-            offset: new BigNumber(0),
-        };
-    }
-
-    public getSize(): BigNumber {
-        return new BigNumber(ethUtil.toBuffer(this.dataType.getHexValue()).byteLength);
-    }
-
-    public assignLocation(calldataSection: CalldataSection, sectionOffset: BigNumber, offset: BigNumber) {
-        this.location.calldataSection = calldataSection;
-        this.location.sectionOffset = sectionOffset;
-        this.location.offset = offset;
-    }
-
-    public get(): string {
-        console.log(`Unstripped = '${this.dataType.getHexValue()}' and Stripped = '${ethUtil.stripHexPrefix(this.dataType.getHexValue())}'`);
-        return ethUtil.stripHexPrefix(this.dataType.getHexValue());
-    }
-
-    public getOffset(): BigNumber {
-        return this.location.offset;
-    }
-
-    public getAbsoluteOffset(): BigNumber {
-        return this.location.sectionOffset.plus(this.location.offset);
-    }
-
-    public getSection(): CalldataSection {
-        return this.location.calldataSection;
-    }
-
-    public getName(): string {
-        return this.dataType.getDataItem().name;
-    }
-}
-
-interface BindList {
-    [key: string]: Memblock;
-}
-
-export class Calldata {
-    private selector: string;
-    private params: Memblock[];
-    private data: Memblock[];
-    private dataOffset: BigNumber;
-    private currentDataOffset: BigNumber;
-    private currentParamOffset: BigNumber;
-    private bindList: BindList;
-
-    constructor(selector: string, nParams: number) {
-        this.selector = selector;
-        this.params = [];
-        this.data = [];
-        const evmWordSize = 32;
-        this.dataOffset = new BigNumber(nParams).times(evmWordSize);
-        this.currentDataOffset = new BigNumber(0);
-        this.currentParamOffset = new BigNumber(0);
-        this.bindList = {};
-    }
-
-    public bind(dataType: DataType, section: CalldataSection) {
-        if (dataType.getId() in this.bindList) {
-            throw `Rebind on ${dataType.getId()}`;
-        }
-        const memblock = new Memblock(dataType);
-
-        this.params.push(memblock);
-        memblock.assignLocation(section, new BigNumber(0), this.currentParamOffset);
-
-        console.log(`Binding ${dataType.getDataItem().name} to PARAMS at ${this.currentParamOffset}`);
-        this.currentParamOffset = this.currentParamOffset.plus(memblock.getSize());
-        console.log("CURRENT PARAM OFFSET -------- 0x", this.currentParamOffset.toString(16));
-
-        /*
-        switch (section) {
-            case CalldataSection.PARAMS:
-                ;
-                break;
-
-            case CalldataSection.DATA:
-                this.data.push(memblock);
-                memblock.assignLocation(section, this.dataOffset, this.currentDataOffset);
-
-                console.log(
-                    `Binding ${dataType.getDataItem().name} to DATA at ${memblock
-                        .getAbsoluteOffset()
-                        .toString(16)}`,
-                );
-                this.currentDataOffset = this.currentDataOffset.plus(memblock.getSize());
-                break;
-
-            default:
-                throw `Unrecognized calldata section: ${section}`;
-        }*/
-
-        this.bindList[dataType.getId()] = memblock;
-        dataType.rbind(memblock);
-    }
-
-    public getHexValue(): string {
-        let hexValue = `${this.selector}`;
-        _.each(this.params, (memblock: Memblock) => {
-            hexValue += memblock.get();
-        });
-        _.each(this.data, (memblock: Memblock) => {
-            hexValue += memblock.get();
-        });
-
-        return hexValue;
-    }
-
-    public printAnnotated() {
-        let hexValue = `${this.selector}`;
-        console.log(hexValue);
-        let offset = new BigNumber(0);
-        _.each(this.params, (memblock: Memblock) => {
-            const offsetStr = `0x${offset.toString(16)}`;
-            const hexValue = memblock.get();
-            const annotation = memblock.getName();
-
-            console.log(`${offsetStr} ${hexValue} ${annotation}`);
-        });
-        _.each(this.data, (memblock: Memblock) => {
-            const offsetStr = `0x${offset.toString(16)}`;
-            const hexValue = memblock.get();
-            const annotation = memblock.getName();
-
-            console.log(`${offsetStr} ${hexValue} ${annotation}`);
-        });
-    }
-}
-
-export abstract class DataType {
-    private dataItem: DataItem;
-    private hexValue: string;
-    protected memblock: Memblock | undefined;
-    protected children: DataType[];
-
-    constructor(dataItem: DataItem) {
-        this.dataItem = dataItem;
-        this.hexValue = '0x';
-        this.memblock = undefined;
-        this.children = [];
-    }
-
-    protected assignHexValue(hexValue: string) {
-        this.hexValue = hexValue;
-    }
-
-    public getHexValue(): string {
-        return this.hexValue;
-    }
-
-    public getDataItem(): DataItem {
-        return this.dataItem;
-    }
-
-    public rbind(memblock: Memblock) {
-        this.memblock = memblock;
-    }
-
-    public bind(calldata: Calldata, section: CalldataSection) {
-        calldata.bind(this, section);
-        _.each(this.getChildren(), (child: DataType) => {
-            child.bind(calldata, CalldataSection.DATA);
-        });
-    }
-
-    public getId(): string {
-        return this.dataItem.name;
-    }
-
-    public getOffset(): BigNumber {
-        if (this.memblock === undefined) return new BigNumber(0);
-        return this.memblock.getOffset();
-    }
-
-    public getAbsoluteOffset(): BigNumber {
-        if (this.memblock === undefined) return new BigNumber(0);
-        return this.memblock.getAbsoluteOffset();
-    }
-    /*
-        public getSize(): BigNumber {
-            if (this.memblock === undefined) return new BigNumber(0);
-            return this.memblock.getSize();
-        }
-        */
-
-    public getChildren(): DataType[] {
-        return this.children;
-    }
-
-    public getSize(): BigNumber {
-        return this.getHeaderSize().plus(this.getBodySize());
-    }
-
-    public abstract assignValue(value: any): void;
-    public abstract getSignature(): string;
-    public abstract isStatic(): boolean;
-    public abstract getHeaderSize(): BigNumber;
-    public abstract getBodySize(): BigNumber;
-}
-
-export abstract class StaticDataType extends DataType {
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-    }
-}
-
-export abstract class DynamicDataType extends DataType {
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-    }
-}
-
-export class Address extends StaticDataType {
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        expect(Address.matchGrammar(dataItem.type)).to.be.true();
-    }
-
-    public assignValue(value: string) {
-        const evmWordWidth = 32;
-        const hexValue = ethUtil.bufferToHex(ethUtil.setLengthLeft(ethUtil.toBuffer(value), evmWordWidth));
-        this.assignHexValue(hexValue);
-    }
-
-    public getSignature(): string {
-        return `address`;
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        return new BigNumber(32);
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return type === 'address';
-    }
-}
-
-export class Bool extends StaticDataType {
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        expect(Bool.matchGrammar(dataItem.type)).to.be.true();
-    }
-
-    public assignValue(value: boolean) {
-        const evmWordWidth = 32;
-        const encodedValue = value === true ? '0x1' : '0x0';
-        const hexValue = ethUtil.bufferToHex(ethUtil.setLengthLeft(ethUtil.toBuffer(encodedValue), evmWordWidth));
-        this.assignHexValue(hexValue);
-    }
-
-    public getSignature(): string {
-        return 'bool';
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        return new BigNumber(32);
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return type === 'bool';
-    }
-}
-
-abstract class Number extends StaticDataType {
-    static MAX_WIDTH: number = 256;
-    static DEFAULT_WIDTH: number = Number.MAX_WIDTH;
-    width: number = Number.DEFAULT_WIDTH;
-
-    constructor(dataItem: DataItem, matcher: RegExp) {
-        super(dataItem);
-        const matches = matcher.exec(dataItem.type);
-        expect(matches).to.be.not.null();
-        if (matches !== null && matches.length === 2 && matches[1] !== undefined) {
-            this.width = parseInt(matches[1]);
-        } else {
-            this.width = 256;
-        }
-    }
-
-    public assignValue(value: BigNumber) {
-        if (value.greaterThan(this.getMaxValue())) {
-            throw `tried to assign value of ${value}, which exceeds max value of ${this.getMaxValue()}`;
-        } else if (value.lessThan(this.getMinValue())) {
-            throw `tried to assign value of ${value}, which exceeds min value of ${this.getMinValue()}`;
-        }
-
-        const hexBase = 16;
-        const evmWordWidth = 32;
-        let valueBuf: Buffer;
-        if (value.greaterThanOrEqualTo(0)) {
-            valueBuf = ethUtil.setLengthLeft(ethUtil.toBuffer(`0x${value.toString(hexBase)}`), evmWordWidth);
-        } else {
-            // BigNumber can't write a negative hex value, so we use twos-complement conversion to do it ourselves.
-            // Step 1/3: Convert value to positive binary string
-            const binBase = 2;
-            const valueBin = value.times(-1).toString(binBase);
-
-            // Step 2/3: Invert binary value
-            const bitsInEvmWord = 256;
-            let invertedValueBin = '1'.repeat(bitsInEvmWord - valueBin.length);
-            _.each(valueBin, (bit: string) => {
-                invertedValueBin += bit === '1' ? '0' : '1';
-            });
-            const invertedValue = new BigNumber(invertedValueBin, binBase);
-
-            // Step 3/3: Add 1 to inverted value
-            // The result is the two's-complement represent of the input value.
-            const negativeValue = invertedValue.plus(1);
-
-            // Convert the negated value to a hex string
-            valueBuf = ethUtil.setLengthLeft(
-                ethUtil.toBuffer(`0x${negativeValue.toString(hexBase)}`),
-                evmWordWidth,
-            );
-        }
-
-        const encodedValue = ethUtil.bufferToHex(valueBuf);
-        this.assignHexValue(encodedValue);
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        return new BigNumber(32);
-    }
-
-    public abstract getMaxValue(): BigNumber;
-    public abstract getMinValue(): BigNumber;
-}
-
-export class Int extends Number {
-    static matcher = RegExp(
-        '^int(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}$',
-    );
-
-    constructor(dataItem: DataItem) {
-        super(dataItem, Int.matcher);
-    }
-
-    public getMaxValue(): BigNumber {
-        return new BigNumber(2).toPower(this.width - 1).sub(1);
-    }
-
-    public getMinValue(): BigNumber {
-        return new BigNumber(2).toPower(this.width - 1).times(-1);
-    }
-
-    public getSignature(): string {
-        return `int${this.width}`;
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return this.matcher.test(type);
-    }
-}
-
-export class UInt extends Number {
-    static 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}$',
-    );
-
-    constructor(dataItem: DataItem) {
-        super(dataItem, UInt.matcher);
-    }
-
-    public getMaxValue(): BigNumber {
-        return new BigNumber(2).toPower(this.width).sub(1);
-    }
-
-    public getMinValue(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getSignature(): string {
-        return `uint${this.width}`;
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return this.matcher.test(type);
-    }
-}
-
-export class Byte extends StaticDataType {
-    static 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))$',
-    );
-
-    static DEFAULT_WIDTH = 1;
-    width: number = Byte.DEFAULT_WIDTH;
-
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        const matches = Byte.matcher.exec(dataItem.type);
-        expect(matches).to.be.not.null();
-        if (matches !== null && matches.length === 3 && matches[2] !== undefined) {
-            this.width = parseInt(matches[2]);
-        } else {
-            this.width = Byte.DEFAULT_WIDTH;
-        }
-    }
-
-    public assignValue(value: string | Buffer) {
-        // Convert value into a buffer and do bounds checking
-        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()}`,
-            );
-        } else if (value.length % 2 !== 0) {
-            throw new Error(`Tried to assign ${value}, which is contains a half-byte. Use full bytes only.`);
-        }
-
-        // Store value as hex
-        const evmWordWidth = 32;
-        const paddedValue = ethUtil.setLengthRight(valueBuf, evmWordWidth);
-        const hexValue = ethUtil.bufferToHex(paddedValue);
-
-        this.assignHexValue(hexValue);
-    }
-
-    public getSignature(): string {
-        // Note that `byte` reduces to `bytes1`
-        return `bytes${this.width}`;
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        return new BigNumber(32);
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return this.matcher.test(type);
-    }
-}
-
-export class Bytes extends DynamicDataType {
-    static UNDEFINED_LENGTH = new BigNumber(-1);
-    length: BigNumber = Bytes.UNDEFINED_LENGTH;
-
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        expect(Bytes.matchGrammar(dataItem.type)).to.be.true();
-    }
-
-    public assignValue(value: string | Buffer) {
-        if (typeof value === 'string' && !value.startsWith('0x')) {
-            throw new Error(`Input value must be hex (prefixed with 0x). Actual value is '${value}'`);
-        }
-        const valueBuf = ethUtil.toBuffer(value);
-        if (value.length % 2 !== 0) {
-            throw new Error(`Tried to assign ${value}, which is contains a half-byte. Use full bytes only.`);
-        }
-
-        const wordsForValue = Math.ceil(valueBuf.byteLength / 32);
-        const paddedBytesForValue = wordsForValue * 32;
-        const paddedValueBuf = ethUtil.setLengthRight(ethUtil.toBuffer(value), paddedBytesForValue);
-        const paddedLengthBuf = ethUtil.setLengthLeft(ethUtil.toBuffer(valueBuf.byteLength), 32);
-        const encodedValueBuf = Buffer.concat([paddedLengthBuf, paddedValueBuf]);
-        const encodedValue = ethUtil.bufferToHex(encodedValueBuf);
-
-        this.assignHexValue(encodedValue);
-    }
-
-    public getSignature(): string {
-        return 'bytes';
-    }
-
-    public isStatic(): boolean {
-        return false;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        const valueBuf = ethUtil.toBuffer(this.getHexValue());
-        const size = new BigNumber(valueBuf.byteLength);
-        return size;
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return type === 'bytes';
-    }
-}
-
-export class SolString extends DynamicDataType {
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        expect(SolString.matchGrammar(dataItem.type)).to.be.true();
-    }
-
-    public assignValue(value: string) {
-        const wordsForValue = Math.ceil(value.length / 32);
-        const paddedBytesForValue = wordsForValue * 32;
-        const valueBuf = ethUtil.setLengthRight(ethUtil.toBuffer(value), paddedBytesForValue);
-        const lengthBuf = ethUtil.setLengthLeft(ethUtil.toBuffer(value.length), 32);
-        const encodedValueBuf = Buffer.concat([lengthBuf, valueBuf]);
-        const encodedValue = ethUtil.bufferToHex(encodedValueBuf);
-
-        this.assignHexValue(encodedValue);
-    }
-
-    public getSignature(): string {
-        return 'string';
-    }
-
-    public isStatic(): boolean {
-        return false;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        const valueBuf = ethUtil.toBuffer(this.getHexValue());
-        const size = new BigNumber(valueBuf.byteLength);
-        return size;
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return type === 'string';
-    }
-}
-
-export class SolArray extends DynamicDataType {
-    static matcher = RegExp('^(.+)\\[([0-9]*)\\]$');
-    static UNDEFINED_LENGTH = new BigNumber(-1);
-    length: BigNumber = SolArray.UNDEFINED_LENGTH;
-    type: string = '[undefined]';
-    isLengthDefined: boolean;
-    isStaticArray: boolean; // An array is dynamic if it's lenghth is undefined or if its children are dynamic.
-    private elements: DataType[];
-
-    /*
-    --- Layout 1: Fixed Length Array with Static Types ---
-    Elem1, Elem2, ..., ElemN
-
-    --- Layout 2: Fixed Length Array with Dynamic Types ---
-    PtrToArray, ..., Elem1, Elem2, ..., ElemN
-
-    --- Layout 3: Dynamic Length Array with Static Types ---
-    PtrToArray, ..., ArrayLength, Elem1, Elem2, ..., ElemN
-
-    --- Layout 4: Dynamic Length Array with Dynamic Types ---
-    PtrToArray, ..., ArrayLength, PtrToElem1, PtrToElem2, ..., PtrToElemN, ..., Elem1, Elem2, ..., ElemN
-    */
-
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        const matches = SolArray.matcher.exec(dataItem.type);
-        expect(matches).to.be.not.null();
-        console.log(JSON.stringify(matches));
-        if (matches === null || matches.length !== 3) {
-            throw new Error(`Could not parse array: ${dataItem.type}`);
-        } else if (matches[1] === undefined) {
-            throw new Error(`Could not parse array type: ${dataItem.type}`);
-        } else if (matches[2] === undefined) {
-            throw new Error(`Could not parse array length: ${dataItem.type}`);
-        }
-
-        this.elements = [];
-
-        // Check if length is undefined
-        if (matches[2] === '') {
-            this.type = matches[1];
-            this.length = SolArray.UNDEFINED_LENGTH;
-            this.isLengthDefined = false;
-            this.isStaticArray = false;
-            return;
-        }
-
-        // Parse out array type/length and construct children
-        this.isLengthDefined = true;
-        this.type = matches[1];
-        this.length = new BigNumber(matches[2], 10);
-        if (this.length.lessThan(1)) {
-            throw new Error(`Bad array length: ${JSON.stringify(this.length)}`);
-        }
-        this.constructChildren();
-
-        // Check if we're static or not
-        this.isStaticArray = !(this.elements[0] instanceof Pointer);  //this.elements[0].isStatic();
-        //throw new Error(`Am I static? ${this.isStaticArray}`);
-    }
-
-    private constructChildren() {
-        for (let idx = new BigNumber(0); idx.lessThan(this.length); idx = idx.plus(1)) {
-            const childDataItem = {
-                type: this.type,
-                name: `${this.getDataItem().name}[${idx.toString(10)}]`,
-            } as DataItem;
-            const components = this.getDataItem().components;
-            if (components !== undefined) {
-                childDataItem.components = components;
-            }
-            const child = DataTypeFactory.create(childDataItem, this);
-            this.elements.push(child);
-            if (child instanceof Pointer) {
-                const pointsTo = child.getChildren()[0];
-                this.children.push(pointsTo); // DataType pointing to
-            }
-        }
-    }
-
-    // @TODO: HACKY -- shouldn't really have children for a 
-    /*
-    public getChildren(): DataType[] {
-        if (this.isStatic()) {
-            return [];
-        } else {
-            return this.children;
-        }
-    }*/
-
-    public assignValue(value: any[]) {
-        console.log('GREG'.repeat(15), JSON.stringify(value));
-
-
-        // Sanity check length
-        const valueLength = new BigNumber(value.length);
-        if (this.length !== SolArray.UNDEFINED_LENGTH && valueLength.equals(this.length) === false) {
-            throw new Error(
-                `Expected array of length ${JSON.stringify(this.length)}, but got array of length ${JSON.stringify(
-                    valueLength,
-                )}`,
-            );
-        }
-
-        // Assign length if not already set
-        if (this.length === SolArray.UNDEFINED_LENGTH) {
-            this.length = valueLength;
-            this.constructChildren();
-        }
-
-        // Assign values to children
-        for (let idx = new BigNumber(0); idx.lessThan(this.length); idx = idx.plus(1)) {
-            const idxNumber = idx.toNumber();
-            this.elements[idxNumber].assignValue(value[idxNumber]);
-        }
-    }
-
-    public getHexValue(): string {
-        let valueBuf = new Buffer("");
-
-        if (this.isLengthDefined === false) {
-            // Must include the array length
-            const lengthBufUnpadded = ethUtil.toBuffer(`0x${this.length.toString(16)}`);
-            const lengthBuf = ethUtil.setLengthLeft(lengthBufUnpadded, 32);
-            valueBuf = lengthBuf;
-        }
-
-        for (let idx = new BigNumber(0); idx.lessThan(this.length); idx = idx.plus(1)) {
-            const idxNumber = idx.toNumber();
-            const childValueHex = this.elements[idxNumber].getHexValue();
-            const childValueBuf = ethUtil.toBuffer(childValueHex);
-            valueBuf = Buffer.concat([valueBuf, childValueBuf]);
-        }
-
-        // Convert value buffer to hex
-        const valueHex = ethUtil.bufferToHex(valueBuf);
-        return valueHex;
-    }
-
-    public isStatic(): boolean {
-        return this.isStaticArray;
-    }
-
-    public getHeaderSize(): BigNumber {
-        let size = new BigNumber(0);
-        if (!this.isLengthDefined) {
-            size = new BigNumber(32); // stores length of bytes
-        }
-        return size;
-    }
-
-    public getBodySize(): BigNumber {
-        const evmWordWidth = new BigNumber(32);
-        const body = this.length.times(evmWordWidth);
-        return body;
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return this.matcher.test(type);
-    }
-
-    public getSignature(): string {
-        let dataItem = {
-            type: this.type,
-            name: 'N/A',
-        } as DataItem;
-        const components = this.getDataItem().components;
-        if (components !== undefined) {
-            dataItem.components = components;
-        }
-        const elementDataType = DataTypeFactory.mapDataItemToDataType(dataItem);
-        const type = elementDataType.getSignature();
-        if (this.length.equals(SolArray.UNDEFINED_LENGTH)) {
-            return `${type}[]`;
-        }
-        return `${type}[${this.length}]`;
-    }
-}
-
-export class Tuple extends DynamicDataType {
-    private length: BigNumber;
-    private childMap: { [key: string]: number };
-    private members: DataType[];
-
-    constructor(dataItem: DataItem) {
-        super(dataItem);
-        expect(Tuple.matchGrammar(dataItem.type)).to.be.true();
-        this.length = new BigNumber(0);
-        this.childMap = {};
-        this.members = [];
-        if (dataItem.components !== undefined) {
-            this.constructChildren(dataItem.components);
-            this.length = new BigNumber(dataItem.components.length);
-        } else {
-            throw new Error('Components undefined');
-        }
-    }
-
-    private constructChildren(dataItems: DataItem[]) {
-        _.each(dataItems, (dataItem: DataItem) => {
-            const childDataItem = {
-                type: dataItem.type,
-                name: `${this.getDataItem().name}.${dataItem.name}`,
-            } as DataItem;
-            const child = DataTypeFactory.create(childDataItem, this);
-            this.childMap[dataItem.name] = this.members.length;
-
-            if (child instanceof Pointer) {
-                this.children.push(child.getChildren()[0]);
-            }
-            this.members.push(child);
-        });
-    }
-
-    private assignValueFromArray(value: any[]) {
-        // Sanity check length
-        const valueLength = new BigNumber(value.length);
-        if (this.length !== SolArray.UNDEFINED_LENGTH && valueLength.equals(this.length) === false) {
-            throw new Error(
-                `Expected array of ${JSON.stringify(
-                    this.length,
-                )} elements, but got array of length ${JSON.stringify(valueLength)}`,
-            );
-        }
-
-        // Assign values to children
-        for (let idx = new BigNumber(0); idx.lessThan(this.length); idx = idx.plus(1)) {
-            const idxNumber = idx.toNumber();
-            this.members[idxNumber].assignValue(value[idxNumber]);
-        }
-    }
-
-    private assignValueFromObject(obj: object) {
-        let childMap = _.cloneDeep(this.childMap);
-        _.forOwn(obj, (value: any, key: string) => {
-            if (key in childMap === false) {
-                throw new Error(`Could not assign tuple to object: unrecognized key '${key}'`);
-            }
-            this.members[this.childMap[key]].assignValue(value);
-            delete childMap[key];
-        });
-
-        if (Object.keys(childMap).length !== 0) {
-            throw new Error(`Could not assign tuple to object: missing keys ${Object.keys(childMap)}`);
-        }
-    }
-
-    public assignValue(value: any[] | object) {
-        if (value instanceof Array) {
-            this.assignValueFromArray(value);
-        } else if (typeof value === 'object') {
-            this.assignValueFromObject(value);
-        } else {
-            throw new Error(`Unexpected type for ${value}`);
-        }
-    }
-
-    public getHexValue(): string {
-        let paramBufs: Buffer[] = [];
-        _.each(this.members, (member: DataType) => {
-            paramBufs.push(ethUtil.toBuffer(member.getHexValue()));
-        });
-
-        const value = Buffer.concat(paramBufs);
-        const hexValue = ethUtil.bufferToHex(value);
-        return hexValue;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        const evmWordWidth = new BigNumber(32);
-        const size = this.length.times(evmWordWidth);
-        return size;
-    }
-
-    public getSignature(): string {
-        // Compute signature
-        let signature = `(`;
-        _.each(this.members, (member: DataType, i: number) => {
-            signature += member.getSignature();
-            if (i < this.members.length - 1) {
-                signature += ',';
-            }
-        });
-        signature += ')';
-        return signature;
-    }
-
-    public isStatic(): boolean {
-        const isStaticTuple = this.children.length === 0;
-        return isStaticTuple; // @TODO: True in every case or only when dynamic data?
-    }
-
-    public static matchGrammar(type: string): boolean {
-        return type === 'tuple';
-    }
-}
-
-/* TODO
-class Fixed extends StaticDataType {}
-
-class UFixed extends StaticDataType {}*/
-
-export class Pointer extends StaticDataType {
-    destDataType: DynamicDataType;
-    parentDataType: DataType;
-
-    constructor(destDataType: DynamicDataType, parentDataType: DataType) {
-        const destDataItem = destDataType.getDataItem();
-        const dataItem = { name: `ptr<${destDataItem.name}>`, type: `ptr<${destDataItem.type}>` } as DataItem;
-        super(dataItem);
-        this.destDataType = destDataType;
-        this.parentDataType = parentDataType;
-        this.children.push(destDataType);
-    }
-
-    /*
-    public assignValue(destDataType: DynamicDataType) {
-        this.destDataType = destDataType;
-    }*/
-
-    public assignValue(value: any) {
-        this.destDataType.assignValue(value);
-    }
-
-    public getHexValue(): string {
-        console.log(
-            '*'.repeat(40),
-            this.destDataType.getAbsoluteOffset().toString(16),
-            '^'.repeat(150),
-            this.parentDataType.getAbsoluteOffset().toString(16),
-        );
-
-        let offset = this.destDataType
-            .getAbsoluteOffset()
-            .minus(this.parentDataType.getAbsoluteOffset())
-            .minus(this.parentDataType.getHeaderSize());
-
-        console.log("OFFSET == ", JSON.stringify(offset), " or in hex -- 0x", offset.toString(16));
-
-        const hexBase = 16;
-        const evmWordWidth = 32;
-        const valueBuf = ethUtil.setLengthLeft(ethUtil.toBuffer(`0x${offset.toString(hexBase)}`), evmWordWidth);
-        const encodedValue = ethUtil.bufferToHex(valueBuf);
-        return encodedValue;
-    }
-
-    public getSignature(): string {
-        return this.destDataType.getSignature();
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        return new BigNumber(32);
-    }
-
-}
-
-export class DataTypeFactory {
-    public static mapDataItemToDataType(dataItem: DataItem): DataType {
-        console.log(`Type: ${dataItem.type}`);
-
-        if (SolArray.matchGrammar(dataItem.type)) return new SolArray(dataItem);
-        if (Address.matchGrammar(dataItem.type)) return new Address(dataItem);
-        if (Bool.matchGrammar(dataItem.type)) return new Bool(dataItem);
-        if (Int.matchGrammar(dataItem.type)) return new Int(dataItem);
-        if (UInt.matchGrammar(dataItem.type)) return new UInt(dataItem);
-        if (Byte.matchGrammar(dataItem.type)) return new Byte(dataItem);
-        if (Tuple.matchGrammar(dataItem.type)) return new Tuple(dataItem);
-        if (SolArray.matchGrammar(dataItem.type)) return new SolArray(dataItem);
-        if (Bytes.matchGrammar(dataItem.type)) return new Bytes(dataItem);
-        if (SolString.matchGrammar(dataItem.type)) return new SolString(dataItem);
-        //if (Fixed.matchGrammar(dataItem.type)) return Fixed(dataItem);
-        //if (UFixed.matchGrammar(dataItem.type)) return UFixed(dataItem);
-
-        throw new Error(`Unrecognized data type: '${dataItem.type}'`);
-    }
-
-    public static create(dataItem: DataItem, parentDataType: DataType): DataType {
-        const dataType = DataTypeFactory.mapDataItemToDataType(dataItem);
-        if (dataType.isStatic()) {
-            return dataType;
-        } else {
-            const pointer = new Pointer(dataType, parentDataType);
-            return pointer;
-        }
-
-        throw new Error(`Unrecognized instance type: '${dataType}'`);
-    }
-}
-
-class Queue<T> {
-    private store: T[] = [];
-    push(val: T) {
-        this.store.push(val);
-    }
-    pop(): T | undefined {
-        return this.store.shift();
-    }
-}
-
-export class Method extends DataType {
-    name: string;
-    params: DataType[];
-    private signature: string;
-    selector: string;
-
-    constructor(abi: MethodAbi) {
-        super({ type: 'method', name: abi.name });
-        this.name = abi.name;
-        this.params = [];
-
-        _.each(abi.inputs, (input: DataItem) => {
-            this.params.push(DataTypeFactory.create(input, this));
-        });
-
-        // Compute signature
-        this.signature = `${this.name}(`;
-        _.each(this.params, (param: DataType, i: number) => {
-            this.signature += param.getSignature();
-            if (i < this.params.length - 1) {
-                this.signature += ',';
-            }
-        });
-        this.signature += ')';
-
-        // Compute selector
-        this.selector = ethUtil.bufferToHex(ethUtil.toBuffer(ethUtil.sha3(this.signature).slice(0, 4)));
-
-        console.log(`--SIGNATURE--\n${this.signature}\n---------\n`);
-        console.log(`--SELECTOR--\n${this.selector}\n---------\n`);
-    }
-
-    public getSignature(): string {
-        return this.signature;
-    }
-
-    public assignValue(args: any[]) {
-        _.each(this.params, (param: DataType, i: number) => {
-            // Assign value to parameter
-            try {
-                param.assignValue(args[i]);
-            } catch (e) {
-                console.log('Failed to assign to ', param.getDataItem().name);
-                throw e;
-            }
-
-            if (param instanceof Pointer) {
-                this.children.push(param.getChildren()[0]);
-            }
-        });
-    }
-
-    public getHexValue(): string {
-        let paramBufs: Buffer[] = [];
-        _.each(this.params, (param: DataType) => {
-            paramBufs.push(ethUtil.toBuffer(param.getHexValue()));
-        });
-
-        const value = Buffer.concat(paramBufs);
-        const hexValue = ethUtil.bufferToHex(value);
-        return hexValue;
-    }
-
-    public encode(args: any[]): string {
-        this.assignValue(args);
-        const calldata = new Calldata(this.selector, this.params.length);
-        calldata.printAnnotated();
-        this.bind(calldata, CalldataSection.PARAMS);
-
-        return calldata.getHexValue();
-    }
-
-    public isStatic(): boolean {
-        return true;
-    }
-
-    public getHeaderSize(): BigNumber {
-        // Exclude selector
-        return new BigNumber(0);
-    }
-
-    public getBodySize(): BigNumber {
-        const nParams = new BigNumber(this.params.length);
-        const evmWordWidth = new BigNumber(32);
-        const size = nParams.times(evmWordWidth);
-        return size;
-    }
-
-    /*
-    encodeOptimized(args: any[]): string {
-        const calldata = new Memory();
-        // Assign values
-        optimizableParams : StaticDataType = [];
-        _.each(this.params, function(args: any[], i: number, param: DataType) {
-            param.assignValue(args[i]);
-            if (param instanceof DynamicDataType) {
-
-            }
-        });
-
-        // Find non-parameter leaves
-
-
-        return '';
-    } */
-
-    /*
-    decode(rawCalldata: string): any[] {
-        const calldata = new Calldata(this.name, this.params.length);
-        calldata.assignRaw(rawCalldata);
-        let args: any[];
-        let params = this.params;
-        _.each(params, function(args: any[], i: number, param: DataType) {
-            param.decodeFromCalldata(calldata);
-            args.push(param.getValue());
-        });
-
-        return args;
-    }*/
-}
\ No newline at end of file
diff --git a/packages/order-utils/test/abi_encoder_test.ts b/packages/order-utils/test/abi_encoder_test.ts
index f46a1812c..d75c9dbf1 100644
--- a/packages/order-utils/test/abi_encoder_test.ts
+++ b/packages/order-utils/test/abi_encoder_test.ts
@@ -410,237 +410,237 @@ describe.only('ABI Encoder', () => {
             expect(calldata).to.be.equal(expectedCalldata);
         });
     });
-
-    describe('Array', () => {
-        it('sample', async () => {
-            const testDataItem = { name: 'testArray', type: 'int[2]' };
-            const dataType = new AbiEncoder.SolArray(testDataItem);
-            console.log(JSON.stringify(dataType, null, 4));
-            console.log('*'.repeat(60));
-            dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
-            console.log(JSON.stringify(dataType, null, 4));
-            const hexValue = dataType.getHexValue();
-            console.log('*'.repeat(60));
-            console.log(hexValue);
-        });
-
-        it('sample undefined size', async () => {
-            const testDataItem = { name: 'testArray', type: 'int[]' };
-            const dataType = new AbiEncoder.SolArray(testDataItem);
-            console.log(JSON.stringify(dataType, null, 4));
-            console.log('*'.repeat(60));
-            dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
-            console.log(JSON.stringify(dataType, null, 4));
-            const hexValue = dataType.getHexValue();
-            console.log('*'.repeat(60));
-            console.log(hexValue);
-        });
-
-        it('sample dynamic types', async () => {
-            const testDataItem = { name: 'testArray', type: 'string[]' };
-            const dataType = new AbiEncoder.SolArray(testDataItem);
-            console.log(JSON.stringify(dataType, null, 4));
-            console.log('*'.repeat(60));
-            dataType.assignValue(['five', 'six', 'seven']);
-            console.log(JSON.stringify(dataType, null, 4));
-            const hexValue = dataType.getHexValue();
-            console.log('*'.repeat(60));
-            console.log(hexValue);
-            const calldata = new AbiEncoder.Calldata('0x01020304', 1);
-            dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
-            console.log('*'.repeat(60));
-            console.log(calldata.getHexValue());
-        });
-    });
-
-    describe('Address', () => {
-        const testAddressDataItem = { name: 'testAddress', type: 'address' };
-        it('Valid Address', async () => {
-            const addressDataType = new AbiEncoder.Address(testAddressDataItem);
-            addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
-            const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
-
-            console.log(addressDataType.getHexValue());
-            console.log(expectedAbiEncodedAddress);
-            expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
-        });
-    });
-
-    describe('Bool', () => {
-        const testBoolDataItem = { name: 'testBool', type: 'bool' };
-        it('True', async () => {
-            const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
-            boolDataType.assignValue(true);
-            const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
-            expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
-        });
-
-        it('False', async () => {
-            const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
-            boolDataType.assignValue(false);
-            const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
-            expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
-        });
-    });
-
-    describe('Integer', () => {
-        const testIntDataItem = { name: 'testInt', type: 'int' };
-        it('Positive - Base case', async () => {
-            const intDataType = new AbiEncoder.Int(testIntDataItem);
-            intDataType.assignValue(new BigNumber(1));
-            const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
-            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-        });
-
-        it('Positive', async () => {
-            const intDataType = new AbiEncoder.Int(testIntDataItem);
-            intDataType.assignValue(new BigNumber(437829473));
-            const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
-            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-        });
-
-        it('Negative - Base case', async () => {
-            const intDataType = new AbiEncoder.Int(testIntDataItem);
-            intDataType.assignValue(new BigNumber(-1));
-            const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
-            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-        });
-
-        it('Negative', async () => {
-            const intDataType = new AbiEncoder.Int(testIntDataItem);
-            intDataType.assignValue(new BigNumber(-437829473));
-            const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
-            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-        });
-
-        // TODO: Add bounds tests + tests for different widths
-    });
-
-    describe('Unsigned Integer', () => {
-        const testIntDataItem = { name: 'testUInt', type: 'uint' };
-        it('Lower Bound', async () => {
-            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-            uintDataType.assignValue(new BigNumber(0));
-            const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
-            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-        });
-
-        it('Base Case', async () => {
-            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-            uintDataType.assignValue(new BigNumber(1));
-            const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
-            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-        });
-
-        it('Random value', async () => {
-            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-            uintDataType.assignValue(new BigNumber(437829473));
-            const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
-            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-        });
-
-        // TODO: Add bounds tests + tests for different widths
-    });
-
-    describe('Static Bytes', () => {
-        it('Byte (padded)', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-            byteDataType.assignValue('0x05');
-            const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
-            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-        });
-
-        it.skip('Byte (no padding)', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-
-            // @TODO: This does not catch the Error
-            expect(byteDataType.assignValue('0x5')).to.throw();
-        });
-
-        it('Bytes1', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-            byteDataType.assignValue('0x05');
-            const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
-            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-        });
-
-        it('Bytes32 (padded)', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-            byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
-            const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
-            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-        });
-
-        it('Bytes32 (unpadded)', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-            byteDataType.assignValue('0x1a18bf61');
-            const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
-            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-        });
-
-        it.skip('Bytes32 - Too long', async () => {
-            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-
-            // @TODO: This does not catch the Error
-            expect(
-                byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
-            ).to.throw(
-                `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
-            );
-        });
-    });
-
-    describe('Bytes (Dynamic)', () => {
-        const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
-        it('Less than 32 bytes', async () => {
-            const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
-            bytesDataType.assignValue('0x010203');
-            const expectedAbiEncodedBytes =
-                '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
-
-            expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
-        });
-
-        it('Greater than 32 bytes', async () => {
-            const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
-            const testValue = '0x' + '61'.repeat(40);
-            bytesDataType.assignValue(testValue);
-            const expectedAbiEncodedBytes =
-                '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
-            expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
-        });
-
-        // @TODO: Add test for throw on half-byte
-        // @TODO: Test with no 0x prefix
-        // @TODO: Test with Buffer as input
-    });
-
-    describe('String', () => {
-        const testStringDataItem = { name: 'testString', type: 'string' };
-        it('Less than 32 bytes', async () => {
-            const stringDataType = new AbiEncoder.SolString(testStringDataItem);
-            stringDataType.assignValue('five');
-            const expectedAbiEncodedString =
-                '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
-
-            console.log(stringDataType.getHexValue());
-            console.log(expectedAbiEncodedString);
-            expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
-        });
-
-        it('Greater than 32 bytes', async () => {
-            const stringDataType = new AbiEncoder.SolString(testStringDataItem);
-            const testValue = 'a'.repeat(40);
-            stringDataType.assignValue(testValue);
-            const expectedAbiEncodedString =
-                '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
-            expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
-        });
-    });
+    /*
+        describe('Array', () => {
+            it('sample', async () => {
+                const testDataItem = { name: 'testArray', type: 'int[2]' };
+                const dataType = new AbiEncoder.SolArray(testDataItem);
+                console.log(JSON.stringify(dataType, null, 4));
+                console.log('*'.repeat(60));
+                dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
+                console.log(JSON.stringify(dataType, null, 4));
+                const hexValue = dataType.getHexValue();
+                console.log('*'.repeat(60));
+                console.log(hexValue);
+            });
+    
+            it('sample undefined size', async () => {
+                const testDataItem = { name: 'testArray', type: 'int[]' };
+                const dataType = new AbiEncoder.SolArray(testDataItem);
+                console.log(JSON.stringify(dataType, null, 4));
+                console.log('*'.repeat(60));
+                dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
+                console.log(JSON.stringify(dataType, null, 4));
+                const hexValue = dataType.getHexValue();
+                console.log('*'.repeat(60));
+                console.log(hexValue);
+            });
+    
+            it('sample dynamic types', async () => {
+                const testDataItem = { name: 'testArray', type: 'string[]' };
+                const dataType = new AbiEncoder.SolArray(testDataItem);
+                console.log(JSON.stringify(dataType, null, 4));
+                console.log('*'.repeat(60));
+                dataType.assignValue(['five', 'six', 'seven']);
+                console.log(JSON.stringify(dataType, null, 4));
+                const hexValue = dataType.getHexValue();
+                console.log('*'.repeat(60));
+                console.log(hexValue);
+                const calldata = new AbiEncoder.Calldata('0x01020304', 1);
+                dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
+                console.log('*'.repeat(60));
+                console.log(calldata.getHexValue());
+            });
+        });
+    
+        describe('Address', () => {
+            const testAddressDataItem = { name: 'testAddress', type: 'address' };
+            it('Valid Address', async () => {
+                const addressDataType = new AbiEncoder.Address(testAddressDataItem);
+                addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
+                const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
+    
+                console.log(addressDataType.getHexValue());
+                console.log(expectedAbiEncodedAddress);
+                expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
+            });
+        });
+    
+        describe('Bool', () => {
+            const testBoolDataItem = { name: 'testBool', type: 'bool' };
+            it('True', async () => {
+                const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+                boolDataType.assignValue(true);
+                const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
+                expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+            });
+    
+            it('False', async () => {
+                const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+                boolDataType.assignValue(false);
+                const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
+                expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+            });
+        });
+    
+        describe('Integer', () => {
+            const testIntDataItem = { name: 'testInt', type: 'int' };
+            it('Positive - Base case', async () => {
+                const intDataType = new AbiEncoder.Int(testIntDataItem);
+                intDataType.assignValue(new BigNumber(1));
+                const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+            });
+    
+            it('Positive', async () => {
+                const intDataType = new AbiEncoder.Int(testIntDataItem);
+                intDataType.assignValue(new BigNumber(437829473));
+                const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+            });
+    
+            it('Negative - Base case', async () => {
+                const intDataType = new AbiEncoder.Int(testIntDataItem);
+                intDataType.assignValue(new BigNumber(-1));
+                const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+            });
+    
+            it('Negative', async () => {
+                const intDataType = new AbiEncoder.Int(testIntDataItem);
+                intDataType.assignValue(new BigNumber(-437829473));
+                const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
+                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+            });
+    
+            // TODO: Add bounds tests + tests for different widths
+        });
+    
+        describe('Unsigned Integer', () => {
+            const testIntDataItem = { name: 'testUInt', type: 'uint' };
+            it('Lower Bound', async () => {
+                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+                uintDataType.assignValue(new BigNumber(0));
+                const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
+                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+            });
+    
+            it('Base Case', async () => {
+                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+                uintDataType.assignValue(new BigNumber(1));
+                const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+            });
+    
+            it('Random value', async () => {
+                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+                uintDataType.assignValue(new BigNumber(437829473));
+                const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+            });
+    
+            // TODO: Add bounds tests + tests for different widths
+        });
+    
+        describe('Static Bytes', () => {
+            it('Byte (padded)', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+                byteDataType.assignValue('0x05');
+                const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+            });
+    
+            it.skip('Byte (no padding)', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+    
+                // @TODO: This does not catch the Error
+                expect(byteDataType.assignValue('0x5')).to.throw();
+            });
+    
+            it('Bytes1', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+                byteDataType.assignValue('0x05');
+                const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+            });
+    
+            it('Bytes32 (padded)', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+                byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
+                const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
+                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+            });
+    
+            it('Bytes32 (unpadded)', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+                byteDataType.assignValue('0x1a18bf61');
+                const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
+                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+            });
+    
+            it.skip('Bytes32 - Too long', async () => {
+                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+    
+                // @TODO: This does not catch the Error
+                expect(
+                    byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
+                ).to.throw(
+                    `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
+                );
+            });
+        });
+    
+        describe('Bytes (Dynamic)', () => {
+            const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
+            it('Less than 32 bytes', async () => {
+                const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+                bytesDataType.assignValue('0x010203');
+                const expectedAbiEncodedBytes =
+                    '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
+    
+                expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+            });
+    
+            it('Greater than 32 bytes', async () => {
+                const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+                const testValue = '0x' + '61'.repeat(40);
+                bytesDataType.assignValue(testValue);
+                const expectedAbiEncodedBytes =
+                    '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+                expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+            });
+    
+            // @TODO: Add test for throw on half-byte
+            // @TODO: Test with no 0x prefix
+            // @TODO: Test with Buffer as input
+        });
+    
+        describe('String', () => {
+            const testStringDataItem = { name: 'testString', type: 'string' };
+            it('Less than 32 bytes', async () => {
+                const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+                stringDataType.assignValue('five');
+                const expectedAbiEncodedString =
+                    '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
+    
+                console.log(stringDataType.getHexValue());
+                console.log(expectedAbiEncodedString);
+                expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+            });
+    
+            it('Greater than 32 bytes', async () => {
+                const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+                const testValue = 'a'.repeat(40);
+                stringDataType.assignValue(testValue);
+                const expectedAbiEncodedString =
+                    '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+                expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+            });
+        });*/
 });