Make methods accept senderAccount

10 files changed, 72 insertions, 125 deletions

diff --git a/src/0x.js.ts b/src/0x.js.ts
index 850827fee..5e2cd9ed9 100644
--- a/src/0x.js.ts
+++ b/src/0x.js.ts
@@ -122,17 +122,11 @@ export class ZeroEx {
         this.token.invalidateContractInstances();
     }
     /**
-     * Sets default account for sending transactions.
+     * Gets accounts available for sending transactions.
      */
-    public setTransactionSenderAccount(account: string): void {
-        this.web3Wrapper.setDefaultAccount(account);
-    }
-    /**
-     * Get the default account set for sending transactions.
-     */
-    public async getTransactionSenderAccountIfExistsAsync(): Promise<string|undefined> {
-        const senderAccountIfExists = await this.web3Wrapper.getSenderAddressIfExistsAsync();
-        return senderAccountIfExists;
+    public async getAvailableAccountsAsync(): Promise<string[]> {
+        const availableAccounts = await this.web3Wrapper.getAvailableAccountsAsync();
+        return availableAccounts;
     }
     /**
      * Computes the orderHash for a given order and returns it as a hex encoded string.
@@ -167,10 +161,10 @@ export class ZeroEx {
      * Signs an orderHash and returns it's elliptic curve signature
      * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
      */
-    public async signOrderHashAsync(orderHashHex: string): Promise<ECSignature> {
+    public async signOrderHashAsync(orderHashHex: string, senderAccount: string): Promise<ECSignature> {
         assert.isHexString('orderHashHex', orderHashHex);
-
-        const makerAddress = await this.web3Wrapper.getSenderAddressOrThrowAsync();
+        await assert.isSenderAccountHexAsync(this.web3Wrapper, senderAccount);
+        const makerAddress = senderAccount;
 
         let msgHashHex;
         const nodeVersion = await this.web3Wrapper.getNodeVersionAsync();
diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index ee0b2696f..459e24608 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -57,7 +57,6 @@ export class ExchangeWrapper extends ContractWrapper {
         assert.doesConformToSchema('ecSignature', ecSignature, ecSignatureSchema);
         assert.isETHAddressHex('signerAddressHex', signerAddressHex);
 
-        const senderAddress = await this.web3Wrapper.getSenderAddressOrThrowAsync();
         const exchangeInstance = await this.getExchangeContractAsync();
 
         const isValidSignature = await exchangeInstance.isValidSignature.call(
@@ -66,9 +65,6 @@ export class ExchangeWrapper extends ContractWrapper {
             ecSignature.v,
             ecSignature.r,
             ecSignature.s,
-            {
-                from: senderAddress,
-            },
         );
         return isValidSignature;
     }
@@ -119,16 +115,16 @@ export class ExchangeWrapper extends ContractWrapper {
      * false forgoes this check and causes the smart contract to throw instead.
      */
     public async fillOrderAsync(signedOrder: SignedOrder, fillTakerAmount: BigNumber.BigNumber,
-                                shouldCheckTransfer: boolean): Promise<void> {
+                                shouldCheckTransfer: boolean, senderAccount: string): Promise<void> {
         assert.doesConformToSchema('signedOrder',
                                    SchemaValidator.convertToJSONSchemaCompatibleObject(signedOrder as object),
                                    signedOrderSchema);
         assert.isBigNumber('fillTakerAmount', fillTakerAmount);
         assert.isBoolean('shouldCheckTransfer', shouldCheckTransfer);
+        await assert.isSenderAccountHexAsync(this.web3Wrapper, senderAccount);
 
-        const senderAddress = await this.web3Wrapper.getSenderAddressOrThrowAsync();
         const exchangeInstance = await this.getExchangeContractAsync();
-        await this.validateFillOrderAndThrowIfInvalidAsync(signedOrder, fillTakerAmount, senderAddress);
+        await this.validateFillOrderAndThrowIfInvalidAsync(signedOrder, fillTakerAmount, senderAccount);
 
         const orderAddresses: OrderAddresses = [
             signedOrder.maker,
@@ -154,7 +150,7 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: senderAddress,
+                from: senderAccount,
             },
         );
         const response: ContractResponse = await exchangeInstance.fill(
@@ -166,7 +162,7 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: senderAddress,
+                from: senderAccount,
                 gas,
             },
         );
@@ -207,11 +203,11 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     private async validateFillOrderAndThrowIfInvalidAsync(signedOrder: SignedOrder,
                                                           fillTakerAmount: BigNumber.BigNumber,
-                                                          senderAddress: string): Promise<void> {
+                                                          senderAccount: string): Promise<void> {
         if (fillTakerAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.ORDER_REMAINING_FILL_AMOUNT_ZERO);
         }
-        if (signedOrder.taker !== constants.NULL_ADDRESS && signedOrder.taker !== senderAddress) {
+        if (signedOrder.taker !== constants.NULL_ADDRESS && signedOrder.taker !== senderAccount) {
             throw new Error(ExchangeContractErrs.TRANSACTION_SENDER_IS_NOT_FILL_ORDER_TAKER);
         }
         const currentUnixTimestampSec = Date.now() / 1000;
@@ -220,7 +216,7 @@ export class ExchangeWrapper extends ContractWrapper {
         }
         const zrxTokenAddress = await this.getZRXTokenAddressAsync();
         await this.validateFillOrderBalancesAndAllowancesAndThrowIfInvalidAsync(signedOrder, fillTakerAmount,
-                                                               senderAddress, zrxTokenAddress);
+                                                               senderAccount, zrxTokenAddress);
 
         const wouldRoundingErrorOccur = await this.isRoundingErrorAsync(
             signedOrder.takerTokenAmount, fillTakerAmount, signedOrder.makerTokenAmount,
@@ -241,16 +237,16 @@ export class ExchangeWrapper extends ContractWrapper {
      */
     private async validateFillOrderBalancesAndAllowancesAndThrowIfInvalidAsync(signedOrder: SignedOrder,
                                                                                fillTakerAmount: BigNumber.BigNumber,
-                                                                               senderAddress: string,
+                                                                               senderAccount: string,
                                                                                zrxTokenAddress: string): Promise<void> {
 
         const makerBalance = await this.tokenWrapper.getBalanceAsync(signedOrder.makerTokenAddress,
                                                                      signedOrder.maker);
-        const takerBalance = await this.tokenWrapper.getBalanceAsync(signedOrder.takerTokenAddress, senderAddress);
+        const takerBalance = await this.tokenWrapper.getBalanceAsync(signedOrder.takerTokenAddress, senderAccount);
         const makerAllowance = await this.tokenWrapper.getProxyAllowanceAsync(signedOrder.makerTokenAddress,
                                                                               signedOrder.maker);
         const takerAllowance = await this.tokenWrapper.getProxyAllowanceAsync(signedOrder.takerTokenAddress,
-                                                                              senderAddress);
+                                                                              senderAccount);
 
         // exchangeRate is the price of one maker token denominated in taker tokens
         const exchangeRate = signedOrder.takerTokenAmount.div(signedOrder.makerTokenAmount);
@@ -271,11 +267,11 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const makerFeeBalance = await this.tokenWrapper.getBalanceAsync(zrxTokenAddress,
                                                                         signedOrder.maker);
-        const takerFeeBalance = await this.tokenWrapper.getBalanceAsync(zrxTokenAddress, senderAddress);
+        const takerFeeBalance = await this.tokenWrapper.getBalanceAsync(zrxTokenAddress, senderAccount);
         const makerFeeAllowance = await this.tokenWrapper.getProxyAllowanceAsync(zrxTokenAddress,
                                                                                  signedOrder.maker);
         const takerFeeAllowance = await this.tokenWrapper.getProxyAllowanceAsync(zrxTokenAddress,
-                                                                                 senderAddress);
+                                                                                 senderAccount);
 
         if (signedOrder.takerFee.greaterThan(takerFeeBalance)) {
             throw new Error(ExchangeContractErrs.INSUFFICIENT_TAKER_FEE_BALANCE);
@@ -302,11 +298,8 @@ export class ExchangeWrapper extends ContractWrapper {
                                        fillTakerAmount: BigNumber.BigNumber,
                                        makerTokenAmount: BigNumber.BigNumber): Promise<boolean> {
         const exchangeInstance = await this.getExchangeContractAsync();
-        const senderAddress = await this.web3Wrapper.getSenderAddressOrThrowAsync();
         const isRoundingError = await exchangeInstance.isRoundingError.call(
-            takerTokenAmount, fillTakerAmount, makerTokenAmount, {
-                from: senderAddress,
-            },
+            takerTokenAmount, fillTakerAmount, makerTokenAmount,
         );
         return isRoundingError;
     }
diff --git a/src/contract_wrappers/token_wrapper.ts b/src/contract_wrappers/token_wrapper.ts
index c8b557d0d..55ad9be29 100644
--- a/src/contract_wrappers/token_wrapper.ts
+++ b/src/contract_wrappers/token_wrapper.ts
@@ -115,21 +115,20 @@ export class TokenWrapper extends ContractWrapper {
     /**
      * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
      * Requires the fromAddress to have sufficient funds and to have approved an allowance of
-     * `amountInBaseUnits` for senderAddress.
+     * `amountInBaseUnits` for senderAccount.
      */
     public async transferFromAsync(tokenAddress: string, fromAddress: string, toAddress: string,
-                                   senderAddress: string, amountInBaseUnits: BigNumber.BigNumber):
+                                   senderAccount: string, amountInBaseUnits: BigNumber.BigNumber):
                                    Promise<void> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
         assert.isETHAddressHex('fromAddress', fromAddress);
         assert.isETHAddressHex('toAddress', toAddress);
-        assert.isETHAddressHex('senderAddress', senderAddress);
+        await assert.isSenderAccountHexAsync(this.web3Wrapper, senderAccount);
         assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
-        await assert.isSenderAddressAvailableAsync(this.web3Wrapper, senderAddress);
 
         const tokenContract = await this.getTokenContractAsync(tokenAddress);
 
-        const fromAddressAllowance = await this.getAllowanceAsync(tokenAddress, fromAddress, senderAddress);
+        const fromAddressAllowance = await this.getAllowanceAsync(tokenAddress, fromAddress, senderAccount);
         if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.INSUFFICIENT_ALLOWANCE_FOR_TRANSFER);
         }
@@ -140,7 +139,7 @@ export class TokenWrapper extends ContractWrapper {
         }
 
         await tokenContract.transferFrom(fromAddress, toAddress, amountInBaseUnits, {
-            from: senderAddress,
+            from: senderAccount,
         });
     }
     private async getTokenContractAsync(tokenAddress: string): Promise<TokenContract> {
diff --git a/src/types.ts b/src/types.ts
index 68194f548..a02bd0252 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -47,7 +47,7 @@ export type CreateContractEvent = (indexFilterValues: IndexFilterValues,
 export interface ExchangeContract {
     isValidSignature: {
         call: (signerAddressHex: string, dataHex: string, v: number, r: string, s: string,
-               txOpts: TxOpts) => Promise<boolean>;
+               txOpts?: TxOpts) => Promise<boolean>;
     };
     LogFill: CreateContractEvent;
     LogCancel: CreateContractEvent;
@@ -60,7 +60,7 @@ export interface ExchangeContract {
     };
     isRoundingError: {
         call: (takerTokenAmount: BigNumber.BigNumber, fillTakerAmount: BigNumber.BigNumber,
-               makerTokenAmount: BigNumber.BigNumber, txOpts: TxOpts) => Promise<boolean>;
+               makerTokenAmount: BigNumber.BigNumber, txOpts?: TxOpts) => Promise<boolean>;
     };
     fill: {
         (orderAddresses: OrderAddresses, orderValues: OrderValues, fillAmount: BigNumber.BigNumber,
diff --git a/src/utils/assert.ts b/src/utils/assert.ts
index 5a31e1b16..2396b8534 100644
--- a/src/utils/assert.ts
+++ b/src/utils/assert.ts
@@ -26,10 +26,14 @@ export const assert = {
         const web3 = new Web3();
         this.assert(web3.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
     },
-    async isSenderAddressAvailableAsync(web3Wrapper: Web3Wrapper, senderAddress: string) {
-        const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddress);
-        assert.assert(isSenderAddressAvailable, 'Specified senderAddress isn\'t available through the \
-                                                 supplied web3 instance');
+    async isSenderAccountHexAsync(web3Wrapper: Web3Wrapper, senderAccount: string): Promise<void> {
+        assert.isETHAddressHex('senderAccount', senderAccount);
+        await assert.isSenderAccountAvailableAsync(web3Wrapper, senderAccount);
+    },
+    async isSenderAccountAvailableAsync(web3Wrapper: Web3Wrapper, senderAccount: string): Promise<void> {
+        const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAccount);
+        assert.assert(isSenderAddressAvailable, `Specified senderAccount ${senderAccount} isn't available through the \
+                                                 supplied web3 instance`);
     },
     isNumber(variableName: string, value: number): void {
         this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
diff --git a/src/web3_wrapper.ts b/src/web3_wrapper.ts
index 9892abcb8..2508c5116 100644
--- a/src/web3_wrapper.ts
+++ b/src/web3_wrapper.ts
@@ -23,20 +23,8 @@ export class Web3Wrapper {
     public setDefaultAccount(address: string): void {
         this.web3.eth.defaultAccount = address;
     }
-    public async getSenderAddressOrThrowAsync(): Promise<string> {
-        const senderAddressIfExists = await this.getSenderAddressIfExistsAsync();
-        assert.assert(!_.isUndefined(senderAddressIfExists), ZeroExError.USER_HAS_NO_ASSOCIATED_ADDRESSES);
-        return senderAddressIfExists as string;
-    }
-    public async getFirstAddressIfExistsAsync(): Promise<string|undefined> {
-        const addresses = await this.getAvailableSenderAddressesAsync();
-        if (_.isEmpty(addresses)) {
-            return undefined;
-        }
-        return addresses[0];
-    }
     public async isSenderAddressAvailableAsync(senderAddress: string): Promise<boolean> {
-        const addresses = await this.getAvailableSenderAddressesAsync();
+        const addresses = await this.getAvailableAccountsAsync();
         return _.includes(addresses, senderAddress);
     }
     public async getNodeVersionAsync(): Promise<string> {
@@ -73,15 +61,7 @@ export class Web3Wrapper {
         const {timestamp} = await promisify(this.web3.eth.getBlock)(blockHash);
         return timestamp;
     }
-    public async getSenderAddressIfExistsAsync(): Promise<string|undefined> {
-        const defaultAccount = this.web3.eth.defaultAccount;
-        if (!_.isUndefined(defaultAccount)) {
-            return defaultAccount;
-        }
-        const firstAccount = await this.getFirstAddressIfExistsAsync();
-        return firstAccount;
-    }
-    private async getAvailableSenderAddressesAsync(): Promise<string[]> {
+    public async getAvailableAccountsAsync(): Promise<string[]> {
         const addresses: string[] = await promisify(this.web3.eth.getAccounts)();
         return addresses;
     }
diff --git a/test/0x.js_test.ts b/test/0x.js_test.ts
index 8686b42eb..a82ec45ba 100644
--- a/test/0x.js_test.ts
+++ b/test/0x.js_test.ts
@@ -191,6 +191,13 @@ describe('ZeroEx library', () => {
     });
     describe('#signOrderHashAsync', () => {
         let stubs: Sinon.SinonStub[] = [];
+        let makerAccount: string;
+        const web3 = web3Factory.create();
+        const zeroEx = new ZeroEx(web3);
+        before('get maker account', async () => {
+            const availableAccounts = await zeroEx.getAvailableAccountsAsync();
+            makerAccount = availableAccounts[0];
+        });
         afterEach(() => {
             // clean up any stubs after the test has completed
             _.each(stubs, s => s.restore());
@@ -203,10 +210,7 @@ describe('ZeroEx library', () => {
                 r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
                 s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
             };
-
-            const web3 = web3Factory.create();
-            const zeroEx = new ZeroEx(web3);
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash);
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAccount);
             expect(ecSignature).to.deep.equal(expectedECSignature);
         });
         it ('should return the correct ECSignature on Parity > V1.6.6', async () => {
@@ -219,9 +223,6 @@ describe('ZeroEx library', () => {
                 r: '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3',
                 s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
             };
-
-            const web3 = web3Factory.create();
-            const zeroEx = new ZeroEx(web3);
             stubs = [
                 Sinon.stub((zeroEx as any).web3Wrapper, 'getNodeVersionAsync')
                     .returns(Promise.resolve(newParityNodeVersion)),
@@ -230,7 +231,7 @@ describe('ZeroEx library', () => {
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash);
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAccount);
             expect(ecSignature).to.deep.equal(expectedECSignature);
         });
         it ('should return the correct ECSignature on Parity < V1.6.6', async () => {
@@ -243,9 +244,6 @@ describe('ZeroEx library', () => {
                 r: '0xc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee0',
                 s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
             };
-
-            const web3 = web3Factory.create();
-            const zeroEx = new ZeroEx(web3);
             stubs = [
                 Sinon.stub((zeroEx as any).web3Wrapper, 'getNodeVersionAsync')
                     .returns(Promise.resolve(newParityNodeVersion)),
@@ -254,7 +252,7 @@ describe('ZeroEx library', () => {
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash);
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAccount);
             expect(ecSignature).to.deep.equal(expectedECSignature);
         });
     });
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index 4f3a48b26..a841f82ec 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -138,9 +138,6 @@ describe('ExchangeWrapper', () => {
             makerTokenAddress = makerToken.address;
             takerTokenAddress = takerToken.address;
         });
-        afterEach('reset default account', () => {
-            zeroEx.setTransactionSenderAccount(userAddresses[0]);
-        });
         describe('failed fills', () => {
             it('should throw when the fill amount is zero', async () => {
                 const fillableAmount = new BigNumber(5);
@@ -148,9 +145,8 @@ describe('ExchangeWrapper', () => {
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 const zeroFillAmount = new BigNumber(0);
-                zeroEx.setTransactionSenderAccount(takerAddress);
                 return expect(zeroEx.exchange.fillOrderAsync(
-                    signedOrder, zeroFillAmount, shouldCheckTransfer,
+                    signedOrder, zeroFillAmount, shouldCheckTransfer, takerAddress,
                 )).to.be.rejectedWith(ExchangeContractErrs.ORDER_REMAINING_FILL_AMOUNT_ZERO);
             });
             it('should throw when sender is not a taker', async () => {
@@ -159,7 +155,7 @@ describe('ExchangeWrapper', () => {
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 return expect(zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmount, shouldCheckTransfer,
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                 )).to.be.rejectedWith(ExchangeContractErrs.TRANSACTION_SENDER_IS_NOT_FILL_ORDER_TAKER);
             });
             it('should throw when order is expired', async () => {
@@ -168,9 +164,8 @@ describe('ExchangeWrapper', () => {
                 const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount, expirationInPast,
                 );
-                zeroEx.setTransactionSenderAccount(takerAddress);
                 return expect(zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmount, shouldCheckTransfer,
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                 )).to.be.rejectedWith(ExchangeContractErrs.ORDER_FILL_EXPIRED);
             });
             describe('should throw when not enough balance or allowance to fulfill the order', () => {
@@ -187,36 +182,32 @@ describe('ExchangeWrapper', () => {
                     await zeroEx.token.transferAsync(
                         takerTokenAddress, takerAddress, coinbase, balanceToSubtractFromMaker,
                     );
-                    zeroEx.setTransactionSenderAccount(takerAddress);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_TAKER_BALANCE);
                 });
                 it('should throw when taker allowance is less than fill amount', async () => {
                     const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
                     await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress,
                         newAllowanceWhichIsLessThanFillAmount);
-                    zeroEx.setTransactionSenderAccount(takerAddress);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_TAKER_ALLOWANCE);
                 });
                 it('should throw when maker balance is less than maker fill amount', async () => {
                     await zeroEx.token.transferAsync(
                         makerTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
                     );
-                    zeroEx.setTransactionSenderAccount(takerAddress);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_MAKER_BALANCE);
                 });
                 it('should throw when maker allowance is less than maker fill amount', async () => {
                     const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
                     await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress,
                         newAllowanceWhichIsLessThanFillAmount);
-                    zeroEx.setTransactionSenderAccount(takerAddress);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_MAKER_ALLOWANCE);
                 });
             });
@@ -228,9 +219,8 @@ describe('ExchangeWrapper', () => {
                     makerAmount, takerAmount,
                 );
                 const fillTakerAmountThatCausesRoundingError = new BigNumber(3);
-                zeroEx.setTransactionSenderAccount(takerAddress);
                 return expect(zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmountThatCausesRoundingError, shouldCheckTransfer,
+                    signedOrder, fillTakerAmountThatCausesRoundingError, shouldCheckTransfer, takerAddress,
                 )).to.be.rejectedWith(ExchangeContractErrs.ORDER_FILL_ROUNDING_ERROR);
             });
             describe('should throw when not enough balance or allowance to pay fees', () => {
@@ -243,7 +233,6 @@ describe('ExchangeWrapper', () => {
                         makerTokenAddress, takerTokenAddress, makerFee, takerFee,
                         makerAddress, takerAddress, fillableAmount, feeRecipient,
                     );
-                    zeroEx.setTransactionSenderAccount(takerAddress);
                 });
                 it('should throw when maker doesn\'t have enough balance to pay fees', async () => {
                     const balanceToSubtractFromMaker = new BigNumber(1);
@@ -251,7 +240,7 @@ describe('ExchangeWrapper', () => {
                         zrxTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
                     );
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_MAKER_FEE_BALANCE);
                 });
                 it('should throw when maker doesn\'t have enough allowance to pay fees', async () => {
@@ -259,7 +248,7 @@ describe('ExchangeWrapper', () => {
                     await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, makerAddress,
                         newAllowanceWhichIsLessThanFees);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_MAKER_FEE_ALLOWANCE);
                 });
                 it('should throw when taker doesn\'t have enough balance to pay fees', async () => {
@@ -268,7 +257,7 @@ describe('ExchangeWrapper', () => {
                         zrxTokenAddress, takerAddress, coinbase, balanceToSubtractFromTaker,
                     );
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_TAKER_FEE_BALANCE);
                 });
                 it('should throw when taker doesn\'t have enough allowance to pay fees', async () => {
@@ -276,7 +265,7 @@ describe('ExchangeWrapper', () => {
                     await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, takerAddress,
                         newAllowanceWhichIsLessThanFees);
                     return expect(zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldCheckTransfer,
+                        signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.INSUFFICIENT_TAKER_FEE_ALLOWANCE);
                 });
             });
@@ -295,8 +284,7 @@ describe('ExchangeWrapper', () => {
                     .to.be.bignumber.equal(0);
                 expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
                     .to.be.bignumber.equal(fillableAmount);
-                zeroEx.setTransactionSenderAccount(takerAddress);
-                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmount, shouldCheckTransfer);
+                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress);
                 expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
                     .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
                 expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
@@ -312,8 +300,7 @@ describe('ExchangeWrapper', () => {
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 const partialFillAmount = new BigNumber(3);
-                zeroEx.setTransactionSenderAccount(takerAddress);
-                await zeroEx.exchange.fillOrderAsync(signedOrder, partialFillAmount, shouldCheckTransfer);
+                await zeroEx.exchange.fillOrderAsync(signedOrder, partialFillAmount, shouldCheckTransfer, takerAddress);
                 expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
                     .to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
                 expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
@@ -331,8 +318,7 @@ describe('ExchangeWrapper', () => {
                     makerTokenAddress, takerTokenAddress, makerFee, takerFee,
                     makerAddress, takerAddress, fillableAmount, feeRecipient,
                 );
-                zeroEx.setTransactionSenderAccount(takerAddress);
-                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmount, shouldCheckTransfer);
+                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress);
                 expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient))
                     .to.be.bignumber.equal(makerFee.plus(takerFee));
             });
@@ -447,8 +433,9 @@ describe('ExchangeWrapper', () => {
                     done();
                 });
                 const fillTakerAmountInBaseUnits = new BigNumber(1);
-                zeroEx.setTransactionSenderAccount(takerAddress);
-                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer);
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer, takerAddress,
+                );
             })();
         });
         it('Outstanding subscriptions are cancelled when zeroEx.setProviderAsync called', (done: DoneCallback) => {
@@ -473,8 +460,9 @@ describe('ExchangeWrapper', () => {
                 });
 
                 const fillTakerAmountInBaseUnits = new BigNumber(1);
-                zeroEx.setTransactionSenderAccount(takerAddress);
-                await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer);
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer, takerAddress,
+                );
             })();
         });
     });
diff --git a/test/utils/fill_scenarios.ts b/test/utils/fill_scenarios.ts
index d186593b9..075906eaa 100644
--- a/test/utils/fill_scenarios.ts
+++ b/test/utils/fill_scenarios.ts
@@ -54,19 +54,14 @@ export class FillScenarios {
     public async createPartiallyFilledSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
                                                        takerAddress: string, fillableAmount: BigNumber.BigNumber,
                                                        partialFillAmount: BigNumber.BigNumber) {
-        const prevSenderAccount = await this.zeroEx.getTransactionSenderAccountIfExistsAsync();
+        const prevSenderAccount = await this.zeroEx.getAvailableAccountsAsync();
         const [makerAddress] = this.userAddresses;
         const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
             makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
             fillableAmount, fillableAmount,
         );
-
-        this.zeroEx.setTransactionSenderAccount(takerAddress);
         const shouldCheckTransfer = false;
-        await this.zeroEx.exchange.fillOrderAsync(signedOrder, partialFillAmount, shouldCheckTransfer);
-
-        // Re-set sender account so as to avoid introducing side-effects
-        this.zeroEx.setTransactionSenderAccount(prevSenderAccount as string);
+        await this.zeroEx.exchange.fillOrderAsync(signedOrder, partialFillAmount, shouldCheckTransfer, takerAddress);
         return signedOrder;
     }
     private async createAsymmetricFillableSignedOrderWithFeesAsync(
@@ -89,14 +84,10 @@ export class FillScenarios {
             await this.zeroEx.token.setProxyAllowanceAsync(this.zrxTokenAddress, takerAddress, takerFee);
         }
 
-        const prevTransactionSenderAccount = await this.zeroEx.getTransactionSenderAccountIfExistsAsync();
-        this.zeroEx.setTransactionSenderAccount(makerAddress);
         const signedOrder = await orderFactory.createSignedOrderAsync(this.zeroEx,
             makerAddress, takerAddress, makerFee, takerFee,
             makerFillableAmount, makerTokenAddress, takerFillableAmount, takerTokenAddress,
             feeRecepient, expirationUnixTimestampSec);
-        // We re-set the transactionSender to avoid introducing side-effects
-        this.zeroEx.setTransactionSenderAccount(prevTransactionSenderAccount as string);
         return signedOrder;
     }
 }
diff --git a/test/utils/order_factory.ts b/test/utils/order_factory.ts
index 373dbddc6..6f5fa7286 100644
--- a/test/utils/order_factory.ts
+++ b/test/utils/order_factory.ts
@@ -36,7 +36,7 @@ export const orderFactory = {
             expirationUnixTimestampSec,
         };
         const orderHash = await zeroEx.getOrderHashHexAsync(order);
-        const ecSignature = await zeroEx.signOrderHashAsync(orderHash);
+        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker);
         const signedOrder: SignedOrder = _.assign(order, {ecSignature});
         return signedOrder;
     },