merge developmentx

2018-03-27 19:16:13 +01:00
parent eb89ef79eb 066d13f5b7
commit 0053762760
113 changed files with 2099 additions and 1620 deletions
--- a/packages/typescript-typings/.npmignore
+++ b/packages/typescript-typings/.npmignore
@@ -0,0 +1,4 @@
+.*
+yarn-error.log
+/scripts/
+/lib/monorepo_scripts/
--- a/packages/typescript-typings/CHANGELOG.md
+++ b/packages/typescript-typings/CHANGELOG.md
@@ -0,0 +1,3 @@
+# CHANGELOG
+
+## v0.x.x - _TBD, 2018_
--- a/packages/typescript-typings/README.md
+++ b/packages/typescript-typings/README.md
@@ -0,0 +1,45 @@
+## @0xproject/typescript-typings
+
+Type repository for external packages used by 0x. This is like our small version of [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped)
+
+## Installation
+
+```bash
+yarn add -D @0xproject/typescript-typings
+```
+
+## Usage
+
+Add the following line within an `compilerOptions` section of your `tsconfig.json`
+
+```json
+"typeRoots": ["node_modules/@0xproject/typescript-typings/types", "node_modules/@types"]
+```
+
+This will allow the TS compiler to first look into that repo and then fallback to DT types.
+
+## Contributing
+
+We strongly encourage that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
+
+### Install Dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Lint
+
+```bash
+yarn lint
+```
--- a/packages/typescript-typings/monorepo_scripts/globals.d.ts
+++ b/packages/typescript-typings/monorepo_scripts/globals.d.ts
@@ -0,0 +1,6 @@
+declare module '*.json' {
+    const json: any;
+    /* tslint:disable */
+    export default json;
+    /* tslint:enable */
+}
--- a/packages/typescript-typings/monorepo_scripts/postpublish.ts
+++ b/packages/typescript-typings/monorepo_scripts/postpublish.ts
@@ -0,0 +1,8 @@
+import { postpublishUtils } from '@0xproject/monorepo-scripts';
+
+import * as packageJSON from '../package.json';
+import * as tsConfigJSON from '../tsconfig.json';
+
+const cwd = `${__dirname}/..`;
+// tslint:disable-next-line:no-floating-promises
+postpublishUtils.runAsync(packageJSON, tsConfigJSON, cwd);
--- a/packages/typescript-typings/package.json
+++ b/packages/typescript-typings/package.json
@@ -0,0 +1,33 @@
+{
+    "name": "@0xproject/typescript-typings",
+    "version": "0.0.1",
+    "description": "0x project typescript type definitions",
+    "scripts": {
+        "build": "tsc && copyfiles -u 1 './lib/**/*' ./scripts",
+        "clean": "shx rm -rf scripts"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/0xProject/0x-monorepo.git"
+    },
+    "author": "Fabio Berger",
+    "contributors": [
+        "Leonid Logvinov <logvinov.leon@gmail.com>"
+    ],
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/0xProject/0x-monorepo/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x-monorepo/packages/typescript-typings#readme",
+    "dependencies": {
+        "bignumber.js": "~4.1.0"
+    },
+    "devDependencies": {
+        "@0xproject/monorepo-scripts": "^0.1.14",
+        "copyfiles": "^1.2.0",
+        "shx": "^0.2.2"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}
--- a/packages/typescript-typings/tsconfig.json
+++ b/packages/typescript-typings/tsconfig.json
@@ -0,0 +1,7 @@
+{
+    "extends": "../../tsconfig",
+    "compilerOptions": {
+        "outDir": "lib"
+    },
+    "include": ["./monorepo_scripts/**/*"]
+}
--- a/packages/typescript-typings/tslint.json
+++ b/packages/typescript-typings/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": ["tslint-config-0xproject"]
+}
--- a/packages/typescript-typings/types/chai-as-promised/index.d.ts
+++ b/packages/typescript-typings/types/chai-as-promised/index.d.ts
@@ -0,0 +1,268 @@
+// Type definitions for chai-as-promised
+// Project: https://github.com/domenic/chai-as-promised/
+// Definitions by: jt000 <https://github.com/jt000>, Yuki Kokubun <https://github.com/Kuniwak>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'chai-as-promised' {
+    function chaiAsPromised(chai: any, utils: any): void;
+    namespace chaiAsPromised {
+
+    }
+    export = chaiAsPromised;
+}
+
+// tslint:disable:no-namespace ban-types member-ordering
+declare namespace Chai {
+    // For BDD API
+    interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
+        eventually: PromisedAssertion;
+        fulfilled: PromisedAssertion;
+        become(expected: any): PromisedAssertion;
+        rejected(): PromisedAssertion;
+        rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
+        notify(fn: Function): PromisedAssertion;
+    }
+
+    // Eventually does not have .then(), but PromisedAssertion have.
+    interface Eventually extends PromisedLanguageChains, PromisedNumericComparison, PromisedTypeComparison {
+        // From chai-as-promised
+        become(expected: PromiseLike<any>): PromisedAssertion;
+        fulfilled: PromisedAssertion;
+        rejected: () => PromisedAssertion;
+        rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
+        notify(fn: Function): PromisedAssertion;
+
+        // From chai
+        not: PromisedAssertion;
+        deep: PromisedDeep;
+        all: PromisedKeyFilter;
+        a: PromisedTypeComparison;
+        an: PromisedTypeComparison;
+        include: PromisedInclude;
+        contain: PromisedInclude;
+        ok: PromisedAssertion;
+        true: () => PromisedAssertion;
+        false: () => PromisedAssertion;
+        null: PromisedAssertion;
+        undefined: PromisedAssertion;
+        exist: PromisedAssertion;
+        empty: PromisedAssertion;
+        arguments: PromisedAssertion;
+        Arguments: PromisedAssertion;
+        equal: PromisedEqual;
+        equals: PromisedEqual;
+        eq: PromisedEqual;
+        eql: PromisedEqual;
+        eqls: PromisedEqual;
+        property: PromisedProperty;
+        ownProperty: PromisedOwnProperty;
+        haveOwnProperty: PromisedOwnProperty;
+        length: PromisedLength;
+        lengthOf: PromisedLength;
+        match(regexp: RegExp | string, message?: string): PromisedAssertion;
+        string(string: string, message?: string): PromisedAssertion;
+        keys: PromisedKeys;
+        key(string: string): PromisedAssertion;
+        throw: PromisedThrow;
+        throws: PromisedThrow;
+        Throw: PromisedThrow;
+        respondTo(method: string, message?: string): PromisedAssertion;
+        itself: PromisedAssertion;
+        satisfy(matcher: Function, message?: string): PromisedAssertion;
+        closeTo(expected: number, delta: number, message?: string): PromisedAssertion;
+        members: PromisedMembers;
+    }
+
+    interface PromisedAssertion extends Eventually, PromiseLike<any> {}
+
+    interface PromisedLanguageChains {
+        eventually: Eventually;
+
+        // From chai
+        to: PromisedAssertion;
+        be: PromisedAssertion;
+        been: PromisedAssertion;
+        is: PromisedAssertion;
+        that: PromisedAssertion;
+        which: PromisedAssertion;
+        and: PromisedAssertion;
+        has: PromisedAssertion;
+        have: PromisedAssertion;
+        with: PromisedAssertion;
+        at: PromisedAssertion;
+        of: PromisedAssertion;
+        same: PromisedAssertion;
+    }
+
+    interface PromisedNumericComparison {
+        above: PromisedNumberComparer;
+        gt: PromisedNumberComparer;
+        greaterThan: PromisedNumberComparer;
+        least: PromisedNumberComparer;
+        gte: PromisedNumberComparer;
+        below: PromisedNumberComparer;
+        lt: PromisedNumberComparer;
+        lessThan: PromisedNumberComparer;
+        most: PromisedNumberComparer;
+        lte: PromisedNumberComparer;
+        within(start: number, finish: number, message?: string): PromisedAssertion;
+    }
+
+    type PromisedNumberComparer = (value: number, message?: string) => PromisedAssertion;
+
+    interface PromisedTypeComparison {
+        (type: string, message?: string): PromisedAssertion;
+        instanceof: PromisedInstanceOf;
+        instanceOf: PromisedInstanceOf;
+    }
+
+    type PromisedInstanceOf = (constructor: Object, message?: string) => PromisedAssertion;
+
+    interface PromisedDeep {
+        equal: PromisedEqual;
+        include: PromisedInclude;
+        property: PromisedProperty;
+    }
+
+    interface PromisedKeyFilter {
+        keys: PromisedKeys;
+    }
+
+    type PromisedEqual = (value: any, message?: string) => PromisedAssertion;
+
+    type PromisedProperty = (name: string, value?: any, message?: string) => PromisedAssertion;
+
+    type PromisedOwnProperty = (name: string, message?: string) => PromisedAssertion;
+
+    interface PromisedLength extends PromisedLanguageChains, PromisedNumericComparison {
+        (length: number, message?: string): PromisedAssertion;
+    }
+
+    interface PromisedInclude {
+        (value: Object | string | number, message?: string): PromisedAssertion;
+        keys: PromisedKeys;
+        members: PromisedMembers;
+        all: PromisedKeyFilter;
+    }
+
+    interface PromisedKeys {
+        (...keys: string[]): PromisedAssertion;
+        (keys: any[]): PromisedAssertion;
+    }
+
+    interface PromisedThrow {
+        (): PromisedAssertion;
+        (expected: string | RegExp, message?: string): PromisedAssertion;
+        (constructor: Error | Function, expected?: string | RegExp, message?: string): PromisedAssertion;
+    }
+
+    type PromisedMembers = (set: any[], message?: string) => PromisedAssertion;
+
+    // For Assert API
+    interface Assert {
+        eventually: PromisedAssert;
+        isFulfilled(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        becomes(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        doesNotBecome(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, expected: any | RegExp, message?: string): PromiseLike<void>;
+        notify(fn: Function): PromiseLike<void>;
+    }
+
+    export interface PromisedAssert {
+        fail(actual?: any, expected?: any, msg?: string, operator?: string): PromiseLike<void>;
+
+        ok(val: any, msg?: string): PromiseLike<void>;
+        notOk(val: any, msg?: string): PromiseLike<void>;
+
+        equal(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        strictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notStrictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        deepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notDeepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        isTrue(val: any, msg?: string): PromiseLike<void>;
+        isFalse(val: any, msg?: string): PromiseLike<void>;
+
+        isNull(val: any, msg?: string): PromiseLike<void>;
+        isNotNull(val: any, msg?: string): PromiseLike<void>;
+
+        isUndefined(val: any, msg?: string): PromiseLike<void>;
+        isDefined(val: any, msg?: string): PromiseLike<void>;
+
+        isFunction(val: any, msg?: string): PromiseLike<void>;
+        isNotFunction(val: any, msg?: string): PromiseLike<void>;
+
+        isObject(val: any, msg?: string): PromiseLike<void>;
+        isNotObject(val: any, msg?: string): PromiseLike<void>;
+
+        isArray(val: any, msg?: string): PromiseLike<void>;
+        isNotArray(val: any, msg?: string): PromiseLike<void>;
+
+        isString(val: any, msg?: string): PromiseLike<void>;
+        isNotString(val: any, msg?: string): PromiseLike<void>;
+
+        isNumber(val: any, msg?: string): PromiseLike<void>;
+        isNotNumber(val: any, msg?: string): PromiseLike<void>;
+
+        isBoolean(val: any, msg?: string): PromiseLike<void>;
+        isNotBoolean(val: any, msg?: string): PromiseLike<void>;
+
+        typeOf(val: any, type: string, msg?: string): PromiseLike<void>;
+        notTypeOf(val: any, type: string, msg?: string): PromiseLike<void>;
+
+        instanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
+        notInstanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
+
+        include(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
+
+        notInclude(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
+
+        match(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
+        notMatch(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
+
+        property(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        deepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notDeepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+
+        propertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+
+        lengthOf(exp: any, len: number, msg?: string): PromiseLike<void>;
+        // alias frenzy
+        throw(fn: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        throws(fn: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throws(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        Throw(fn: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        doesNotThrow(fn: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, regExp: RegExp): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        operator(val: any, operator: string, val2: any, msg?: string): PromiseLike<void>;
+        closeTo(act: number, exp: number, delta: number, msg?: string): PromiseLike<void>;
+
+        sameMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
+        includeMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
+
+        ifError(val: any, msg?: string): PromiseLike<void>;
+    }
+}
--- a/packages/typescript-typings/types/chai/index.d.ts
+++ b/packages/typescript-typings/types/chai/index.d.ts
--- a/packages/typescript-typings/types/ethers-contracts/index.d.ts
+++ b/packages/typescript-typings/types/ethers-contracts/index.d.ts
@@ -0,0 +1,28 @@
+declare module 'ethers-contracts' {
+    export interface TransactionDescription {
+        name: string;
+        signature: string;
+        sighash: string;
+        data: string;
+    }
+    export interface CallDescription extends TransactionDescription {
+        parse: (...args: any[]) => any;
+    }
+    export interface FunctionDescription {
+        (...params: any[]): TransactionDescription | CallDescription;
+        inputs: { names: string[]; types: string[] };
+        outputs: { names: string[]; types: string[] };
+    }
+    export interface EventDescription {
+        parse: (...args: any[]) => any;
+        inputs: { names: string[]; types: string[] };
+        signature: string;
+        topic: string;
+    }
+    export class Interface {
+        public functions: { [functionName: string]: FunctionDescription };
+        public events: { [eventName: string]: EventDescription };
+        public static decodeParams(types: string[], data: string): any[];
+        constructor(abi: any);
+    }
+}
--- a/packages/typescript-typings/types/web3/index.d.ts
+++ b/packages/typescript-typings/types/web3/index.d.ts
@@ -0,0 +1,440 @@
+declare module 'web3' {
+    import * as BigNumber from 'bignumber.js';
+
+    type MixedData = string | number | object | any[] | BigNumber.BigNumber;
+
+    class Web3 {
+        public static providers: typeof providers;
+        public currentProvider: Web3.Provider;
+
+        public eth: Web3.EthApi;
+        public personal: Web3.PersonalApi | undefined;
+        public version: Web3.VersionApi;
+        public net: Web3.NetApi;
+
+        public constructor(provider?: Web3.Provider);
+
+        public isConnected(): boolean;
+        public setProvider(provider: Web3.Provider): void;
+        public reset(keepIsSyncing: boolean): void;
+        public toHex(data: MixedData): string;
+        public toAscii(hex: string): string;
+        public fromAscii(ascii: string, padding?: number): string;
+        public toDecimal(hex: string): number;
+        public fromDecimal(value: number | string): string;
+        public fromWei(value: number | string, unit: Web3.Unit): string;
+        public fromWei(value: BigNumber.BigNumber, unit: Web3.Unit): BigNumber.BigNumber;
+        public toWei(amount: number | string, unit: Web3.Unit): string;
+        public toWei(amount: BigNumber.BigNumber, unit: Web3.Unit): BigNumber.BigNumber;
+        public toBigNumber(value: number | string): BigNumber.BigNumber;
+        public isAddress(address: string): boolean;
+        public isChecksumAddress(address: string): boolean;
+        public sha3(value: string, options?: Web3.Sha3Options): string;
+    }
+
+    namespace providers {
+        class HttpProvider implements Web3.Provider {
+            constructor(url?: string, timeout?: number, username?: string, password?: string);
+            public sendAsync(
+                payload: Web3.JSONRPCRequestPayload,
+                callback: (err: Error, result: Web3.JSONRPCResponsePayload) => void,
+            ): void;
+        }
+    }
+
+    namespace Web3 {
+        type ContractAbi = AbiDefinition[];
+
+        type AbiDefinition = FunctionAbi | EventAbi;
+
+        type FunctionAbi = MethodAbi | ConstructorAbi | FallbackAbi;
+
+        enum AbiType {
+            Function = 'function',
+            Constructor = 'constructor',
+            Event = 'event',
+            Fallback = 'fallback',
+        }
+
+        type ConstructorStateMutability = 'nonpayable' | 'payable';
+        type StateMutability = 'pure' | 'view' | ConstructorStateMutability;
+
+        interface MethodAbi {
+            type: AbiType.Function;
+            name: string;
+            inputs: DataItem[];
+            outputs: DataItem[];
+            constant: boolean;
+            stateMutability: StateMutability;
+            payable: boolean;
+        }
+
+        interface ConstructorAbi {
+            type: AbiType.Constructor;
+            inputs: DataItem[];
+            payable: boolean;
+            stateMutability: ConstructorStateMutability;
+        }
+
+        interface FallbackAbi {
+            type: AbiType.Fallback;
+            payable: boolean;
+        }
+
+        interface EventParameter extends DataItem {
+            indexed: boolean;
+        }
+
+        interface EventAbi {
+            type: AbiType.Event;
+            name: string;
+            inputs: EventParameter[];
+            anonymous: boolean;
+        }
+
+        interface DataItem {
+            name: string;
+            type: string;
+            components: DataItem[];
+        }
+
+        interface ContractInstance {
+            address: string;
+            abi: Web3.ContractAbi;
+            [name: string]: any;
+        }
+
+        interface Contract<A extends ContractInstance> {
+            at(address: string): A;
+            getData(...args: any[]): string;
+            'new'(...args: any[]): A;
+        }
+
+        interface FilterObject {
+            fromBlock?: number | string;
+            toBlock?: number | string;
+            address?: string;
+            topics?: LogTopic[];
+        }
+
+        type LogTopic = null | string | string[];
+
+        interface DecodedLogEntry<A> extends LogEntry {
+            event: string;
+            args: A;
+        }
+
+        interface DecodedLogEntryEvent<A> extends DecodedLogEntry<A> {
+            removed: boolean;
+        }
+
+        interface LogEntryEvent extends LogEntry {
+            removed: boolean;
+        }
+
+        interface FilterResult {
+            get(callback: () => void): void;
+            watch(callback: (err: Error, result: LogEntryEvent) => void): void;
+            stopWatching(callback?: () => void): void;
+        }
+
+        export interface JSONRPCRequestPayload {
+            params: any[];
+            method: string;
+            id: number;
+            jsonrpc: string;
+        }
+
+        export interface JSONRPCResponsePayload {
+            result: any;
+            id: number;
+            jsonrpc: string;
+        }
+
+        export type OpCode = string;
+
+        export interface StructLog {
+            depth: number;
+            error: string;
+            gas: number;
+            gasCost: number;
+            memory: string[];
+            op: OpCode;
+            pc: number;
+            stack: string[];
+            storage: { [location: string]: string };
+        }
+        export interface TransactionTrace {
+            gas: number;
+            returnValue: any;
+            structLogs: StructLog[];
+        }
+
+        interface Provider {
+            sendAsync(
+                payload: JSONRPCRequestPayload,
+                callback: (err: Error, result: JSONRPCResponsePayload) => void,
+            ): void;
+        }
+
+        interface Sha3Options {
+            encoding: 'hex';
+        }
+
+        interface EthApi {
+            coinbase: string;
+            mining: boolean;
+            hashrate: number;
+            gasPrice: BigNumber.BigNumber;
+            accounts: string[];
+            blockNumber: number;
+            defaultAccount?: string;
+            defaultBlock: Web3.BlockParam;
+            syncing: Web3.SyncingResult;
+            compile: {
+                solidity(sourceString: string, cb?: (err: Error, result: any) => void): object;
+            };
+            getMining(cd: (err: Error, mining: boolean) => void): void;
+            getHashrate(cd: (err: Error, hashrate: number) => void): void;
+            getGasPrice(cd: (err: Error, gasPrice: BigNumber.BigNumber) => void): void;
+            getAccounts(cd: (err: Error, accounts: string[]) => void): void;
+            getBlockNumber(callback: (err: Error, blockNumber: number) => void): void;
+            getSyncing(cd: (err: Error, syncing: Web3.SyncingResult) => void): void;
+            isSyncing(cb: (err: Error, isSyncing: boolean, syncingState: Web3.SyncingState) => void): Web3.IsSyncing;
+
+            getBlock(hashStringOrBlockNumber: string | Web3.BlockParam): Web3.BlockWithoutTransactionData;
+            getBlock(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                callback: (err: Error, blockObj: Web3.BlockWithoutTransactionData) => void,
+            ): void;
+            getBlock(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                returnTransactionObjects: true,
+            ): Web3.BlockWithTransactionData;
+            getBlock(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                returnTransactionObjects: true,
+                callback: (err: Error, blockObj: Web3.BlockWithTransactionData) => void,
+            ): void;
+
+            getBlockTransactionCount(hashStringOrBlockNumber: string | Web3.BlockParam): number;
+            getBlockTransactionCount(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                callback: (err: Error, blockTransactionCount: number) => void,
+            ): void;
+
+            // TODO returnTransactionObjects
+            getUncle(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                uncleNumber: number,
+            ): Web3.BlockWithoutTransactionData;
+            getUncle(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                uncleNumber: number,
+                callback: (err: Error, uncle: Web3.BlockWithoutTransactionData) => void,
+            ): void;
+
+            getTransaction(transactionHash: string): Web3.Transaction;
+            getTransaction(
+                transactionHash: string,
+                callback: (err: Error, transaction: Web3.Transaction) => void,
+            ): void;
+
+            getTransactionFromBlock(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                indexNumber: number,
+            ): Web3.Transaction;
+            getTransactionFromBlock(
+                hashStringOrBlockNumber: string | Web3.BlockParam,
+                indexNumber: number,
+                callback: (err: Error, transaction: Web3.Transaction) => void,
+            ): void;
+
+            contract(abi: Web3.AbiDefinition[]): Web3.Contract<any>;
+
+            // TODO block param
+            getBalance(addressHexString: string): BigNumber.BigNumber;
+            getBalance(addressHexString: string, callback: (err: Error, result: BigNumber.BigNumber) => void): void;
+
+            // TODO block param
+            getStorageAt(address: string, position: number): string;
+            getStorageAt(address: string, position: number, callback: (err: Error, storage: string) => void): void;
+
+            // TODO block param
+            getCode(addressHexString: string): string;
+            getCode(addressHexString: string, callback: (err: Error, code: string) => void): void;
+
+            filter(value: string | Web3.FilterObject): Web3.FilterResult;
+
+            sendTransaction(txData: Web3.TxData): string;
+            sendTransaction(txData: Web3.TxData, callback: (err: Error, value: string) => void): void;
+
+            sendRawTransaction(rawTxData: string): string;
+            sendRawTransaction(rawTxData: string, callback: (err: Error, value: string) => void): void;
+
+            sign(address: string, data: string): string;
+            sign(address: string, data: string, callback: (err: Error, signature: string) => void): void;
+
+            getTransactionReceipt(txHash: string): Web3.TransactionReceipt | null;
+            getTransactionReceipt(
+                txHash: string,
+                callback: (err: Error, receipt: Web3.TransactionReceipt | null) => void,
+            ): void;
+
+            // TODO block param
+            call(callData: Web3.CallData): string;
+            call(callData: Web3.CallData, callback: (err: Error, result: string) => void): void;
+
+            estimateGas(callData: Web3.CallData): number;
+            estimateGas(callData: Web3.CallData, callback: (err: Error, gas: number) => void): void;
+
+            // TODO defaultBlock
+            getTransactionCount(address: string): number;
+            getTransactionCount(address: string, callback: (err: Error, count: number) => void): void;
+        }
+
+        interface VersionApi {
+            api: string;
+            network: string;
+            node: string;
+            ethereum: string;
+            whisper: string;
+            getNetwork(cd: (err: Error, networkId: string) => void): void;
+            getNode(cd: (err: Error, nodeVersion: string) => void): void;
+            getEthereum(cd: (err: Error, ethereum: string) => void): void;
+            getWhisper(cd: (err: Error, whisper: string) => void): void;
+        }
+
+        interface PersonalApi {
+            listAccounts: string[] | undefined;
+            newAccount(password?: string): string;
+            unlockAccount(address: string, password?: string, duration?: number): boolean;
+            lockAccount(address: string): boolean;
+            sign(message: string, account: string, password: string): string;
+            sign(hexMessage: string, account: string, callback: (error: Error, signature: string) => void): void;
+        }
+
+        interface NetApi {
+            listening: boolean;
+            peerCount: number;
+            getListening(cd: (err: Error, listening: boolean) => void): void;
+            getPeerCount(cd: (err: Error, peerCount: number) => void): void;
+        }
+
+        type BlockParam = number | 'earliest' | 'latest' | 'pending';
+
+        type Unit =
+            | 'kwei'
+            | 'ada'
+            | 'mwei'
+            | 'babbage'
+            | 'gwei'
+            | 'shannon'
+            | 'szabo'
+            | 'finney'
+            | 'ether'
+            | 'kether'
+            | 'grand'
+            | 'einstein'
+            | 'mether'
+            | 'gether'
+            | 'tether';
+
+        interface SyncingState {
+            startingBlock: number;
+            currentBlock: number;
+            highestBlock: number;
+        }
+        type SyncingResult = false | SyncingState;
+
+        interface IsSyncing {
+            addCallback(cb: (err: Error, isSyncing: boolean, syncingState: SyncingState) => void): void;
+            stopWatching(): void;
+        }
+
+        interface AbstractBlock {
+            number: number | null;
+            hash: string | null;
+            parentHash: string;
+            nonce: string | null;
+            sha3Uncles: string;
+            logsBloom: string | null;
+            transactionsRoot: string;
+            stateRoot: string;
+            miner: string;
+            difficulty: BigNumber.BigNumber;
+            totalDifficulty: BigNumber.BigNumber;
+            extraData: string;
+            size: number;
+            gasLimit: number;
+            gasUsed: number;
+            timestamp: number;
+            uncles: string[];
+        }
+        interface BlockWithoutTransactionData extends AbstractBlock {
+            transactions: string[];
+        }
+        interface BlockWithTransactionData extends AbstractBlock {
+            transactions: Transaction[];
+        }
+
+        interface Transaction {
+            hash: string;
+            nonce: number;
+            blockHash: string | null;
+            blockNumber: number | null;
+            transactionIndex: number | null;
+            from: string;
+            to: string | null;
+            value: BigNumber.BigNumber;
+            gasPrice: BigNumber.BigNumber;
+            gas: number;
+            input: string;
+        }
+
+        interface CallTxDataBase {
+            to?: string;
+            value?: number | string | BigNumber.BigNumber;
+            gas?: number | string | BigNumber.BigNumber;
+            gasPrice?: number | string | BigNumber.BigNumber;
+            data?: string;
+            nonce?: number;
+        }
+
+        interface TxData extends CallTxDataBase {
+            from: string;
+        }
+
+        interface CallData extends CallTxDataBase {
+            from?: string;
+        }
+
+        interface TransactionReceipt {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            transactionIndex: number;
+            from: string;
+            to: string;
+            status: null | string | 0 | 1;
+            cumulativeGasUsed: number;
+            gasUsed: number;
+            contractAddress: string | null;
+            logs: LogEntry[];
+        }
+
+        interface LogEntry {
+            logIndex: number | null;
+            transactionIndex: number | null;
+            transactionHash: string;
+            blockHash: string | null;
+            blockNumber: number | null;
+            address: string;
+            data: string;
+            topics: string[];
+        }
+    }
+    /* tslint:disable */
+    export = Web3;
+    /* tslint:enable */
+}