Merge pull request #94 from 0xProject/moveExchangeAddressGetters

Moves exchange contract address getters to zeroEx top level

9 files changed, 79 insertions, 84 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bedc6611e..2fdabfd92 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # CHANGELOG
 
+v0.9.0 - TBD
+------------------------
+    * Move `zeroEx.exchange.getAvailableContractAddressesAsync` to `zeroEx.getAvailableExchangeContractAddressesAsync` (#94)
+    * Move `zeroEx.exchange.getProxyAuthorizedContractAddressesAsync` to `zeroEx.getProxyAuthorizedExchangeContractAddressesAsync` (#94)
+
 v0.8.0 - _Jul. 4, 2017_
 ------------------------
     * Add the ability to call methods on different authorized versions of the Exchange smart contract (#82)
diff --git a/src/0x.ts b/src/0x.ts
index 49bd31f2d..95935c258 100644
--- a/src/0x.ts
+++ b/src/0x.ts
@@ -20,6 +20,7 @@ import {ECSignature, ZeroExError, Order, SignedOrder, Web3Provider} from './type
 import {orderHashSchema} from './schemas/order_hash_schema';
 import {orderSchema} from './schemas/order_schemas';
 import {SchemaValidator} from './utils/schema_validator';
+import {ExchangeArtifactsByName} from './exchange_artifacts_by_name';
 
 // Customize our BigNumber instances
 bigNumberConfigs.configure();
@@ -158,12 +159,12 @@ export class ZeroEx {
         this._web3Wrapper = new Web3Wrapper(provider);
         this.token = new TokenWrapper(this._web3Wrapper);
         this.proxy = new ProxyWrapper(this._web3Wrapper);
-        this.exchange = new ExchangeWrapper(this._web3Wrapper, this.token, this.proxy);
+        this.exchange = new ExchangeWrapper(this._web3Wrapper, this.token);
         this.tokenRegistry = new TokenRegistryWrapper(this._web3Wrapper);
         this.etherToken = new EtherTokenWrapper(this._web3Wrapper, this.token);
     }
     /**
-     * Sets a new provider for the web3 instance used by 0x.js. Updating the provider will stop all
+     * Sets a new web3 provider for 0x.js. Updating the provider will stop all
      * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
      * @param   provider    The Web3Provider you would like the 0x.js library to use from now on.
      */
@@ -176,7 +177,7 @@ export class ZeroEx {
         (this.etherToken as any)._invalidateContractInstance();
     }
     /**
-     * Get user Ethereum addresses available through the supplied web3 instance available for sending transactions.
+     * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
      * @return  An array of available user Ethereum addresses.
      */
     public async getAvailableAddressesAsync(): Promise<string[]> {
@@ -254,4 +255,42 @@ export class ZeroEx {
         }
         return ecSignature;
     }
+    /**
+     * Returns the ethereum addresses of all available exchange contracts
+     * supported by this library on the network that the supplied web3
+     * provider is connected to
+     * @return  The ethereum addresses of all available exchange contracts.
+     */
+    public async getAvailableExchangeContractAddressesAsync(): Promise<string[]> {
+        const networkId = await this._web3Wrapper.getNetworkIdIfExistsAsync();
+        if (_.isUndefined(networkId)) {
+            return [];
+        } else {
+            const exchangeArtifacts = _.values(ExchangeArtifactsByName);
+            const networkSpecificExchangeArtifacts = _.compact(_.map(
+                exchangeArtifacts, exchangeArtifact => exchangeArtifact.networks[networkId]));
+            const exchangeAddresses = _.map(
+                networkSpecificExchangeArtifacts,
+                networkSpecificExchangeArtifact => networkSpecificExchangeArtifact.address,
+            );
+            return exchangeAddresses;
+        }
+    }
+    /**
+     * Returns the ethereum addresses of all available exchange contracts
+     * supported by this library on the network that the supplied web3
+     * provider is connected to that are currently authorized by the Proxy contract
+     * @return  The ethereum addresses of all available and authorized exchange contract.
+     */
+    public async getProxyAuthorizedExchangeContractAddressesAsync(): Promise<string[]> {
+        const exchangeContractAddresses = await this.getAvailableExchangeContractAddressesAsync();
+        const proxyAuthorizedExchangeContractAddresses = [];
+        for (const exchangeContractAddress of exchangeContractAddresses) {
+            const isAuthorized = await this.proxy.isAuthorizedAsync(exchangeContractAddress);
+            if (isAuthorized) {
+                proxyAuthorizedExchangeContractAddresses.push(exchangeContractAddress);
+            }
+        }
+        return proxyAuthorizedExchangeContractAddresses;
+    }
 }
diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index 5a2da4a98..2353c826a 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -37,7 +37,6 @@ import {utils} from '../utils/utils';
 import {eventUtils} from '../utils/event_utils';
 import {ContractWrapper} from './contract_wrapper';
 import {ProxyWrapper} from './proxy_wrapper';
-import {ExchangeArtifactsByName} from '../exchange_artifacts_by_name';
 import {ecSignatureSchema} from '../schemas/ec_signature_schema';
 import {signedOrdersSchema} from '../schemas/signed_orders_schema';
 import {subscriptionOptsSchema} from '../schemas/subscription_opts_schema';
@@ -50,6 +49,7 @@ import {signedOrderSchema, orderSchema} from '../schemas/order_schemas';
 import {constants} from '../utils/constants';
 import {TokenWrapper} from './token_wrapper';
 import {decorators} from '../utils/decorators';
+import {ExchangeArtifactsByName} from '../exchange_artifacts_by_name';
 
 /**
  * This class includes all the functionality related to calling methods and subscribing to
@@ -67,7 +67,6 @@ export class ExchangeWrapper extends ContractWrapper {
     private _exchangeContractByAddress: ExchangeContractByAddress;
     private _exchangeLogEventEmitters: ContractEventEmitter[];
     private _tokenWrapper: TokenWrapper;
-    private _proxyWrapper: ProxyWrapper;
     private static _getOrderAddressesAndValues(order: Order): [OrderAddresses, OrderValues] {
         const orderAddresses: OrderAddresses = [
             order.maker,
@@ -86,10 +85,9 @@ export class ExchangeWrapper extends ContractWrapper {
         ];
         return [orderAddresses, orderValues];
     }
-    constructor(web3Wrapper: Web3Wrapper, tokenWrapper: TokenWrapper, proxyWrapper: ProxyWrapper) {
+    constructor(web3Wrapper: Web3Wrapper, tokenWrapper: TokenWrapper) {
         super(web3Wrapper);
         this._tokenWrapper = tokenWrapper;
-        this._proxyWrapper = proxyWrapper;
         this._exchangeLogEventEmitters = [];
         this._exchangeContractByAddress = {};
     }
@@ -610,43 +608,6 @@ export class ExchangeWrapper extends ContractWrapper {
         return eventEmitter;
     }
     /**
-     * Returns the ethereum addresses of all available exchange contracts
-     * on the network that the provided web3 instance is connected to
-     * @return  The ethereum addresses of all available exchange contracts.
-     */
-    public async getAvailableContractAddressesAsync(): Promise<string[]> {
-        const networkId = await this._web3Wrapper.getNetworkIdIfExistsAsync();
-        if (_.isUndefined(networkId)) {
-            return [];
-        } else {
-            const exchangeArtifacts = _.values(ExchangeArtifactsByName);
-            const networkSpecificExchangeArtifacts = _.compact(_.map(
-                exchangeArtifacts, exchangeArtifact => exchangeArtifact.networks[networkId]));
-            const exchangeAddresses = _.map(
-                networkSpecificExchangeArtifacts,
-                networkSpecificExchangeArtifact => networkSpecificExchangeArtifact.address,
-            );
-            return exchangeAddresses;
-        }
-    }
-    /**
-     * Returns the ethereum addresses of all available exchange contracts
-     * on the network that the provided web3 instance is connected to
-     * that are currently authorized on the Proxy contract
-     * @return  The ethereum addresses of all available and authorized exchange contract.
-     */
-    public async getProxyAuthorizedContractAddressesAsync(): Promise<string[]> {
-        const exchangeContractAddresses = await this.getAvailableContractAddressesAsync();
-        const proxyAuthorizedExchangeContractAddresses = [];
-        for (const exchangeContractAddress of exchangeContractAddresses) {
-            const isAuthorized = await this._isExchangeContractAddressProxyAuthorizedAsync(exchangeContractAddress);
-            if (isAuthorized) {
-                proxyAuthorizedExchangeContractAddresses.push(exchangeContractAddress);
-            }
-        }
-        return proxyAuthorizedExchangeContractAddresses;
-    }
-    /**
      * Stops watching for all exchange events
      */
     public async stopWatchingAllEventsAsync(): Promise<void> {
@@ -659,10 +620,6 @@ export class ExchangeWrapper extends ContractWrapper {
         await this.stopWatchingAllEventsAsync();
         this._exchangeContractByAddress = {};
     }
-    private async _isExchangeContractAddressProxyAuthorizedAsync(exchangeContractAddress: string): Promise<boolean> {
-        const isAuthorized = await this._proxyWrapper.isAuthorizedAsync(exchangeContractAddress);
-        return isAuthorized;
-    }
     private async _isValidSignatureUsingContractCallAsync(dataHex: string, ecSignature: ECSignature,
                                                           signerAddressHex: string,
                                                           exchangeContractAddress: string): Promise<boolean> {
diff --git a/src/utils/assert.ts b/src/utils/assert.ts
index b3c30c11d..00415602d 100644
--- a/src/utils/assert.ts
+++ b/src/utils/assert.ts
@@ -43,12 +43,12 @@ export const assert = {
         assert.isETHAddressHex(variableName, senderAddressHex);
         const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddressHex);
         assert.assert(isSenderAddressAvailable,
-            `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 instance`,
+            `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`,
         );
     },
     async isUserAddressAvailableAsync(web3Wrapper: Web3Wrapper): Promise<void> {
         const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
-        this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 instance');
+        this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 provider');
     },
     hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
         this.assert(_.uniq(value).length <= 1, errMsg);
diff --git a/test/0x.js_test.ts b/test/0x.js_test.ts
index 50db402c4..0d8d63985 100644
--- a/test/0x.js_test.ts
+++ b/test/0x.js_test.ts
@@ -6,17 +6,18 @@ import * as BigNumber from 'bignumber.js';
 import * as Sinon from 'sinon';
 import {ZeroEx, Order} from '../src';
 import {constants} from './utils/constants';
+import {assert} from '../src/utils/assert';
 import {web3Factory} from './utils/web3_factory';
 
 chaiSetup.configure();
 const expect = chai.expect;
 
 describe('ZeroEx library', () => {
+    const web3 = web3Factory.create();
+    const zeroEx = new ZeroEx(web3.currentProvider);
     describe('#setProvider', () => {
         it('overrides provider in nested web3s and invalidates contractInstances', async () => {
-            const web3 = web3Factory.create();
-            const zeroEx = new ZeroEx(web3.currentProvider);
-            const [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
+            const [exchangeContractAddress] = await zeroEx.getAvailableExchangeContractAddressesAsync();
             // Instantiate the contract instances with the current provider
             await (zeroEx.exchange as any)._getExchangeContractAsync(exchangeContractAddress);
             await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
@@ -32,7 +33,7 @@ describe('ZeroEx library', () => {
             expect((zeroEx.exchange as any)._exchangeContractByAddress[exchangeContractAddress]).to.be.undefined();
             expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.be.undefined();
 
-            // Check that all nested web3 instances return the updated provider
+            // Check that all nested web3 wrapper instances return the updated provider
             const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getCurrentProvider();
             expect((nestedWeb3WrapperProvider as any).zeroExTestId).to.be.a('number');
             const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
@@ -51,11 +52,9 @@ describe('ZeroEx library', () => {
             s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
         };
         const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-        const web3 = web3Factory.create();
-        const zeroEx = new ZeroEx(web3.currentProvider);
         let exchangeContractAddress: string;
         before(async () => {
-            [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
+            [exchangeContractAddress] = await zeroEx.getAvailableExchangeContractAddressesAsync();
         });
         it('should return false if the data doesn\'t pertain to the signature & address', async () => {
             expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
@@ -148,9 +147,6 @@ describe('ZeroEx library', () => {
             expirationUnixTimestampSec: new BigNumber(0),
         };
         it('calculates the order hash', async () => {
-            const web3 = web3Factory.create();
-            const zeroEx = new ZeroEx(web3.currentProvider);
-
             const orderHash = zeroEx.getOrderHashHex(order);
             expect(orderHash).to.be.equal(expectedOrderHash);
         });
@@ -158,8 +154,6 @@ describe('ZeroEx library', () => {
     describe('#signOrderHashAsync', () => {
         let stubs: Sinon.SinonStub[] = [];
         let makerAddress: string;
-        const web3 = web3Factory.create();
-        const zeroEx = new ZeroEx(web3.currentProvider);
         before(async () => {
             const availableAddreses = await zeroEx.getAvailableAddressesAsync();
             makerAddress = availableAddreses[0];
@@ -222,4 +216,22 @@ describe('ZeroEx library', () => {
             expect(ecSignature).to.deep.equal(expectedECSignature);
         });
     });
+    describe('#getAvailableExchangeContractAddressesAsync', () => {
+        it('returns the exchange contract addresses', async () => {
+            const exchangeAddresses = await zeroEx.getAvailableExchangeContractAddressesAsync();
+            _.map(exchangeAddresses, exchangeAddress => {
+                assert.isETHAddressHex('exchangeAddress', exchangeAddress);
+            });
+        });
+    });
+    describe('#getProxyAuthorizedExchangeContractAddressesAsync', () => {
+        it('returns the Proxy authorized exchange contract addresses', async () => {
+            const exchangeAddresses = await zeroEx.getProxyAuthorizedExchangeContractAddressesAsync();
+            for (const exchangeAddress of exchangeAddresses) {
+                assert.isETHAddressHex('exchangeAddress', exchangeAddress);
+                const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(exchangeAddress);
+                expect(isAuthorized).to.be.true();
+            }
+        });
+    });
 });
diff --git a/test/artifacts_test.ts b/test/artifacts_test.ts
index 22d55a2ee..8393250aa 100644
--- a/test/artifacts_test.ts
+++ b/test/artifacts_test.ts
@@ -27,7 +27,7 @@ describe('Artifacts', () => {
             await (zeroEx.token as any)._getProxyAddressAsync();
         }).timeout(TIMEOUT);
         it('exchange contract is deployed', async () => {
-            const exchangeContractAddresses = await zeroEx.exchange.getAvailableContractAddressesAsync();
+            const exchangeContractAddresses = await zeroEx.getAvailableExchangeContractAddressesAsync();
             expect(exchangeContractAddresses).to.have.lengthOf.above(0);
         }).timeout(TIMEOUT);
     });
diff --git a/test/assert_test.ts b/test/assert_test.ts
index 6a8d30716..bfca95d9c 100644
--- a/test/assert_test.ts
+++ b/test/assert_test.ts
@@ -21,7 +21,7 @@ describe('Assertion library', () => {
             const varName = 'address';
             return expect(assert.isSenderAddressAsync(varName, validUnrelatedAddress, (zeroEx as any)._web3Wrapper))
                 .to.be.rejectedWith(
-                    `Specified ${varName} ${validUnrelatedAddress} isn't available through the supplied web3 instance`,
+                    `Specified ${varName} ${validUnrelatedAddress} isn't available through the supplied web3 provider`,
                 );
         });
         it('doesn\'t throw if address is available', async () => {
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index 0321eb569..45da44f54 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -44,7 +44,7 @@ describe('ExchangeWrapper', () => {
     before(async () => {
         web3 = web3Factory.create();
         zeroEx = new ZeroEx(web3.currentProvider);
-        [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
+        [exchangeContractAddress] = await zeroEx.getAvailableExchangeContractAddressesAsync();
         userAddresses = await promisify(web3.eth.getAccounts)();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
@@ -819,22 +819,4 @@ describe('ExchangeWrapper', () => {
             expect(orderHash).to.equal(orderHashFromContract);
         });
     });
-    describe('#getAvailableContractAddressesAsync', () => {
-        it('returns the exchange contract addresses', async () => {
-            const exchangeAddresses = await zeroEx.exchange.getAvailableContractAddressesAsync();
-            _.map(exchangeAddresses, exchangeAddress => {
-                assert.isETHAddressHex('exchangeAddress', exchangeAddress);
-            });
-        });
-    });
-    describe('#getProxyAuthorizedContractAddressesAsync', () => {
-        it('returns the Proxy authorized exchange contract addresses', async () => {
-            const exchangeAddresses = await zeroEx.exchange.getProxyAuthorizedContractAddressesAsync();
-            for (const exchangeAddress of exchangeAddresses) {
-                assert.isETHAddressHex('exchangeAddress', exchangeAddress);
-                const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(exchangeAddress);
-                expect(isAuthorized).to.be.true();
-            }
-        });
-    });
 });
diff --git a/test/proxy_wrapper_test.ts b/test/proxy_wrapper_test.ts
index c60159b81..c7f1a080a 100644
--- a/test/proxy_wrapper_test.ts
+++ b/test/proxy_wrapper_test.ts
@@ -13,7 +13,7 @@ describe('ProxyWrapper', () => {
     before(async () => {
         const web3 = web3Factory.create();
         zeroEx = new ZeroEx(web3.currentProvider);
-        [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
+        [exchangeContractAddress] = await zeroEx.getAvailableExchangeContractAddressesAsync();
     });
     describe('#isAuthorizedAsync', () => {
         it('should return false if the address is not authorized', async () => {