Merge pull request #561 from 0xProject/feature/contracts/txorigin

Add Validator signature type

8 files changed, 185 insertions, 12 deletions

diff --git a/packages/contracts/test/asset_proxy_owner.ts b/packages/contracts/test/asset_proxy_owner.ts
index db68b5678..43c5da512 100644
--- a/packages/contracts/test/asset_proxy_owner.ts
+++ b/packages/contracts/test/asset_proxy_owner.ts
@@ -36,6 +36,12 @@ describe('AssetProxyOwner', () => {
     let multiSigWrapper: MultiSigWrapper;
 
     before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owners = [accounts[0], accounts[1]];
         const initialOwner = (authorized = accounts[0]);
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index be8d14cb0..bc476a5ee 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -460,10 +460,11 @@ describe('Exchange core', () => {
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
             });
 
+            const v = ethUtil.toBuffer(signedOrder.signature.slice(0, 4));
             const invalidR = ethUtil.sha3('invalidR');
             const invalidS = ethUtil.sha3('invalidS');
-            const signatureTypeAndV = signedOrder.signature.slice(0, 6);
-            const invalidSigBuff = Buffer.concat([ethUtil.toBuffer(signatureTypeAndV), invalidR, invalidS]);
+            const signatureType = ethUtil.toBuffer(`0x${signedOrder.signature.slice(-2)}`);
+            const invalidSigBuff = Buffer.concat([v, invalidR, invalidS, signatureType]);
             const invalidSigHex = `0x${invalidSigBuff.toString('hex')}`;
             signedOrder.signature = invalidSigHex;
             return expect(exchangeWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(
diff --git a/packages/contracts/test/exchange/libs.ts b/packages/contracts/test/exchange/libs.ts
index bbca54274..a3282876b 100644
--- a/packages/contracts/test/exchange/libs.ts
+++ b/packages/contracts/test/exchange/libs.ts
@@ -49,7 +49,6 @@ describe('Exchange libs', () => {
 
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
-        signedOrder = orderFactory.newSignedOrder();
     });
     afterEach(async () => {
         await blockchainLifecycle.revertAsync();
@@ -69,7 +68,8 @@ describe('Exchange libs', () => {
             });
         });
         describe('getOrderHash', () => {
-            it('should output the correct order hash', async () => {
+            it('should output the correct orderHash', async () => {
+                signedOrder = orderFactory.newSignedOrder();
                 const orderHashHex = await libs.publicGetOrderHash.callAsync(signedOrder);
                 expect(orderUtils.getOrderHashHex(signedOrder)).to.be.equal(orderHashHex);
             });
diff --git a/packages/contracts/test/exchange/signature_validator.ts b/packages/contracts/test/exchange/signature_validator.ts
index 376fff438..1f030b742 100644
--- a/packages/contracts/test/exchange/signature_validator.ts
+++ b/packages/contracts/test/exchange/signature_validator.ts
@@ -53,7 +53,6 @@ describe('MixinSignatureValidator', () => {
 
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
-        signedOrder = orderFactory.newSignedOrder();
     });
     afterEach(async () => {
         await blockchainLifecycle.revertAsync();
@@ -75,13 +74,11 @@ describe('MixinSignatureValidator', () => {
         });
 
         it('should return false with an invalid signature', async () => {
+            const v = ethUtil.toBuffer(signedOrder.signature.slice(0, 4));
             const invalidR = ethUtil.sha3('invalidR');
             const invalidS = ethUtil.sha3('invalidS');
-            const invalidSigBuff = Buffer.concat([
-                ethUtil.toBuffer(signedOrder.signature.slice(0, 6)),
-                invalidR,
-                invalidS,
-            ]);
+            const signatureType = ethUtil.toBuffer(`0x${signedOrder.signature.slice(-2)}`);
+            const invalidSigBuff = Buffer.concat([v, invalidR, invalidS, signatureType]);
             const invalidSigHex = `0x${invalidSigBuff.toString('hex')}`;
             signedOrder.signature = invalidSigHex;
             const orderHashHex = orderUtils.getOrderHashHex(signedOrder);
diff --git a/packages/contracts/test/exchange/transactions.ts b/packages/contracts/test/exchange/transactions.ts
index 33fe11bfa..6b3083ae5 100644
--- a/packages/contracts/test/exchange/transactions.ts
+++ b/packages/contracts/test/exchange/transactions.ts
@@ -1,4 +1,5 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { generatePseudoRandomSalt } from '@0xproject/order-utils';
 import { Order, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
@@ -8,6 +9,7 @@ import * as Web3 from 'web3';
 import { DummyERC20TokenContract } from '../../src/contract_wrappers/generated/dummy_e_r_c20_token';
 import { ERC20ProxyContract } from '../../src/contract_wrappers/generated/e_r_c20_proxy';
 import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
+import { WhitelistContract } from '../../src/contract_wrappers/generated/whitelist';
 import { artifacts } from '../../src/utils/artifacts';
 import { assetProxyUtils } from '../../src/utils/asset_proxy_utils';
 import { chaiSetup } from '../../src/utils/chai_setup';
@@ -55,6 +57,8 @@ describe('Exchange transactions', () => {
 
     let defaultMakerTokenAddress: string;
     let defaultTakerTokenAddress: string;
+    let makerPrivateKey: Buffer;
+    let takerPrivateKey: Buffer;
 
     before(async () => {
         await blockchainLifecycle.startAsync();
@@ -98,8 +102,8 @@ describe('Exchange transactions', () => {
             makerAssetData: assetProxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress),
             takerAssetData: assetProxyUtils.encodeERC20ProxyData(defaultTakerTokenAddress),
         };
-        const makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
-        const takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
+        makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
         orderFactory = new OrderFactory(makerPrivateKey, defaultOrderParams);
         makerTransactionFactory = new TransactionFactory(makerPrivateKey, exchange.address);
         takerTransactionFactory = new TransactionFactory(takerPrivateKey, exchange.address);
@@ -203,4 +207,131 @@ describe('Exchange transactions', () => {
             });
         });
     });
+
+    describe('Whitelist', () => {
+        let whitelist: WhitelistContract;
+        let whitelistOrderFactory: OrderFactory;
+
+        before(async () => {
+            whitelist = await WhitelistContract.deployFrom0xArtifactAsync(
+                artifacts.Whitelist,
+                provider,
+                txDefaults,
+                exchange.address,
+            );
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await exchange.approveSignatureValidator.sendTransactionAsync(whitelist.address, isApproved, {
+                    from: takerAddress,
+                }),
+            );
+            const defaultOrderParams = {
+                ...constants.STATIC_ORDER_PARAMS,
+                senderAddress: whitelist.address,
+                exchangeAddress: exchange.address,
+                makerAddress,
+                feeRecipientAddress,
+                makerAssetData: assetProxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress),
+                takerAssetData: assetProxyUtils.encodeERC20ProxyData(defaultTakerTokenAddress),
+            };
+            whitelistOrderFactory = new OrderFactory(makerPrivateKey, defaultOrderParams);
+        });
+
+        beforeEach(async () => {
+            signedOrder = whitelistOrderFactory.newSignedOrder();
+            erc20Balances = await erc20Wrapper.getBalancesAsync();
+        });
+
+        it('should revert if maker has not been whitelisted', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await whitelist.updateWhitelistStatus.sendTransactionAsync(takerAddress, isApproved, { from: owner }),
+            );
+
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            const salt = generatePseudoRandomSalt();
+            return expect(
+                whitelist.fillOrderIfWhitelisted.sendTransactionAsync(
+                    orderStruct,
+                    takerAssetFillAmount,
+                    salt,
+                    signedOrder.signature,
+                    { from: takerAddress },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should revert if taker has not been whitelisted', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await whitelist.updateWhitelistStatus.sendTransactionAsync(makerAddress, isApproved, { from: owner }),
+            );
+
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            const salt = generatePseudoRandomSalt();
+            return expect(
+                whitelist.fillOrderIfWhitelisted.sendTransactionAsync(
+                    orderStruct,
+                    takerAssetFillAmount,
+                    salt,
+                    signedOrder.signature,
+                    { from: takerAddress },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should fill the order if maker and taker have been whitelisted', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await whitelist.updateWhitelistStatus.sendTransactionAsync(makerAddress, isApproved, { from: owner }),
+            );
+
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await whitelist.updateWhitelistStatus.sendTransactionAsync(takerAddress, isApproved, { from: owner }),
+            );
+
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            const salt = generatePseudoRandomSalt();
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await whitelist.fillOrderIfWhitelisted.sendTransactionAsync(
+                    orderStruct,
+                    takerAssetFillAmount,
+                    salt,
+                    signedOrder.signature,
+                    { from: takerAddress },
+                ),
+            );
+
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+
+            const makerAssetFillAmount = signedOrder.makerAssetAmount;
+            const makerFeePaid = signedOrder.makerFee;
+            const takerFeePaid = signedOrder.takerFee;
+
+            expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
+                erc20Balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFillAmount),
+            );
+            expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
+                erc20Balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
+            );
+            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
+                erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
+            );
+            expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
+                erc20Balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
+            );
+            expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
+                erc20Balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFillAmount),
+            );
+            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
+                erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
+            );
+            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
+                erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
+            );
+        });
+    });
 });
diff --git a/packages/contracts/test/libraries/lib_bytes.ts b/packages/contracts/test/libraries/lib_bytes.ts
index 968bac300..e817951ab 100644
--- a/packages/contracts/test/libraries/lib_bytes.ts
+++ b/packages/contracts/test/libraries/lib_bytes.ts
@@ -22,6 +22,7 @@ describe('LibBytes', () => {
     let owner: string;
     let libBytes: TestLibBytesContract;
     const byteArrayShorterThan32Bytes = '0x012345';
+    const byteArrayShorterThan20Bytes = byteArrayShorterThan32Bytes;
     const byteArrayLongerThan32Bytes =
         '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
     const byteArrayLongerThan32BytesFirstBytesSwapped =
@@ -60,6 +61,36 @@ describe('LibBytes', () => {
         await blockchainLifecycle.revertAsync();
     });
 
+    describe('popByte', () => {
+        it('should revert if length is 0', async () => {
+            return expect(libBytes.publicPopByte.callAsync(constants.NULL_BYTES)).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should pop the last byte from the input and return it', async () => {
+            const [newBytes, poppedByte] = await libBytes.publicPopByte.callAsync(byteArrayLongerThan32Bytes);
+            const expectedNewBytes = byteArrayLongerThan32Bytes.slice(0, -2);
+            const expectedPoppedByte = `0x${byteArrayLongerThan32Bytes.slice(-2)}`;
+            expect(newBytes).to.equal(expectedNewBytes);
+            expect(poppedByte).to.equal(expectedPoppedByte);
+        });
+    });
+
+    describe('popAddress', () => {
+        it('should revert if length is less than 20', async () => {
+            return expect(libBytes.publicPopAddress.callAsync(byteArrayShorterThan20Bytes)).to.be.rejectedWith(
+                constants.REVERT,
+            );
+        });
+
+        it('should pop the last 20 bytes from the input and return it', async () => {
+            const [newBytes, poppedAddress] = await libBytes.publicPopAddress.callAsync(byteArrayLongerThan32Bytes);
+            const expectedNewBytes = byteArrayLongerThan32Bytes.slice(0, -40);
+            const expectedPoppedAddress = `0x${byteArrayLongerThan32Bytes.slice(-40)}`;
+            expect(newBytes).to.equal(expectedNewBytes);
+            expect(poppedAddress).to.equal(expectedPoppedAddress);
+        });
+    });
+
     describe('areBytesEqual', () => {
         it('should return true if byte arrays are equal (both arrays < 32 bytes)', async () => {
             const areBytesEqual = await libBytes.publicAreBytesEqual.callAsync(
diff --git a/packages/contracts/test/multi_sig_with_time_lock.ts b/packages/contracts/test/multi_sig_with_time_lock.ts
index ace0f0045..7b7885a00 100644
--- a/packages/contracts/test/multi_sig_with_time_lock.ts
+++ b/packages/contracts/test/multi_sig_with_time_lock.ts
@@ -27,6 +27,12 @@ describe('MultiSigWalletWithTimeLock', () => {
     const SECONDS_TIME_LOCKED = new BigNumber(1000000);
 
     before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owners = [accounts[0], accounts[1]];
     });
diff --git a/packages/contracts/test/token_registry.ts b/packages/contracts/test/token_registry.ts
index 1cc519c53..7980977c8 100644
--- a/packages/contracts/test/token_registry.ts
+++ b/packages/contracts/test/token_registry.ts
@@ -23,6 +23,7 @@ describe('TokenRegistry', () => {
     let notOwner: string;
     let tokenReg: TokenRegistryContract;
     let tokenRegWrapper: TokenRegWrapper;
+
     before(async () => {
         await blockchainLifecycle.startAsync();
     });