Refactor 0x.js to V2

1 files changed, 29 insertions, 39 deletions

diff --git a/packages/0x.js/test/0x.js_test.ts b/packages/0x.js/test/0x.js_test.ts
index 815f94de1..722049955 100644
--- a/packages/0x.js/test/0x.js_test.ts
+++ b/packages/0x.js/test/0x.js_test.ts
@@ -5,11 +5,11 @@ import * as chai from 'chai';
 import * as _ from 'lodash';
 import 'mocha';
 
-import { ApprovalContractEventArgs, LogWithDecodedArgs, TokenEvents, ZeroEx } from '../src';
+import { ERC20TokenApprovalEventArgs, ERC20TokenEvents, LogWithDecodedArgs, ZeroEx } from '../src';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { TokenUtils } from './utils/token_utils';
+import { tokenUtils } from './utils/token_utils';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@@ -45,40 +45,34 @@ describe('ZeroEx library', () => {
         });
     });
     describe('#isValidSignature', () => {
-        // The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes
-        // the length of the data is exactly 32 bytes. Thus for these tests, we use data of this size.
         const dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-        const signature = {
-            v: 27,
-            r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-            s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-        };
+        const ethSignSignature =
+            '0x1B61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc3340349190569279751135161d22529dc25add4f6069af05be04cacbda2ace225403';
         const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
         it("should return false if the data doesn't pertain to the signature & address", async () => {
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync('0x0', signature, address),
-            ).to.become(false);
+            return expect((zeroEx.exchange as any).isValidSignatureAsync('0x0', address, ethSignSignature)).to.become(
+                false,
+            );
         });
         it("should return false if the address doesn't pertain to the signature & data", async () => {
             const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
             return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(
-                    dataHex,
-                    signature,
-                    validUnrelatedAddress,
-                ),
+                (zeroEx.exchange as any).isValidSignatureAsync(dataHex, validUnrelatedAddress, ethSignSignature),
             ).to.become(false);
         });
         it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
-            const wrongSignature = _.assign({}, signature, { v: 28 });
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, wrongSignature, address),
-            ).to.become(false);
+            const signatureArray = ethSignSignature.split('');
+            // tslint:disable-next-line:custom-no-magic-numbers
+            signatureArray[5] = 'C'; // V = 28, instead of 27
+            const wrongSignature = signatureArray.join('');
+            return expect((zeroEx.exchange as any).isValidSignatureAsync(dataHex, address, wrongSignature)).to.become(
+                false,
+            );
         });
         it('should return true if the signature does pertain to the dataHex & address', async () => {
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature, address),
-            ).to.become(true);
+            return expect((zeroEx.exchange as any).isValidSignatureAsync(dataHex, address, ethSignSignature)).to.become(
+                true,
+            );
         });
     });
     describe('#toUnitAmount', () => {
@@ -123,18 +117,16 @@ describe('ZeroEx library', () => {
         it('returns transaction receipt with decoded logs', async () => {
             const availableAddresses = await zeroEx.getAvailableAddressesAsync();
             const coinbase = availableAddresses[0];
-            const tokens = await zeroEx.tokenRegistry.getTokensAsync();
-            const tokenUtils = new TokenUtils(tokens);
-            const zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-            const proxyAddress = zeroEx.proxy.getContractAddress();
-            const txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
+            const zrxTokenAddress = tokenUtils.getProtocolTokenAddress();
+            const erc20ProxyAddress = zeroEx.erc20Proxy.getContractAddress();
+            const txHash = await zeroEx.erc20Token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
             const txReceiptWithDecodedLogs = await zeroEx.awaitTransactionMinedAsync(txHash);
             // tslint:disable-next-line:no-unnecessary-type-assertion
-            const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ApprovalContractEventArgs>;
-            expect(log.event).to.be.equal(TokenEvents.Approval);
+            const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ERC20TokenApprovalEventArgs>;
+            expect(log.event).to.be.equal(ERC20TokenEvents.Approval);
             expect(log.args._owner).to.be.equal(coinbase);
-            expect(log.args._spender).to.be.equal(proxyAddress);
-            expect(log.args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+            expect(log.args._spender).to.be.equal(erc20ProxyAddress);
+            expect(log.args._value).to.be.bignumber.equal(zeroEx.erc20Token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
         });
     });
     describe('#config', () => {
@@ -146,15 +138,13 @@ describe('ZeroEx library', () => {
             const zeroExWithWrongExchangeAddress = new ZeroEx(provider, zeroExConfig);
             expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
         });
-        it('allows to specify token registry token contract address', async () => {
+        it('allows to specify erc20Proxy contract address', async () => {
             const zeroExConfig = {
-                tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
+                erc20ProxyContractAddress: ZeroEx.NULL_ADDRESS,
                 networkId: constants.TESTRPC_NETWORK_ID,
             };
-            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(provider, zeroExConfig);
-            expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
-                ZeroEx.NULL_ADDRESS,
-            );
+            const zeroExWithWrongERC20ProxyAddress = new ZeroEx(provider, zeroExConfig);
+            expect(zeroExWithWrongERC20ProxyAddress.erc20Proxy.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
         });
     });
 });