aboutsummaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/0x.js_test.ts33
-rw-r--r--test/artifacts_test.ts8
-rw-r--r--test/exchange_wrapper_test.ts131
-rw-r--r--test/proxy_wrapper_test.ts23
-rw-r--r--test/utils/fill_scenarios.ts7
-rw-r--r--test/utils/order_factory.ts4
6 files changed, 145 insertions, 61 deletions
diff --git a/test/0x.js_test.ts b/test/0x.js_test.ts
index 9ec0a0c8e..50db402c4 100644
--- a/test/0x.js_test.ts
+++ b/test/0x.js_test.ts
@@ -16,10 +16,11 @@ describe('ZeroEx library', () => {
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();
// Instantiate the contract instances with the current provider
- await (zeroEx.exchange as any)._getExchangeContractAsync();
+ await (zeroEx.exchange as any)._getExchangeContractAsync(exchangeContractAddress);
await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
- expect((zeroEx.exchange as any)._exchangeContractIfExists).to.not.be.undefined();
+ expect((zeroEx.exchange as any)._exchangeContractByAddress[exchangeContractAddress]).to.not.be.undefined();
expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.not.be.undefined();
const newProvider = web3Factory.getRpcProvider();
@@ -28,7 +29,7 @@ describe('ZeroEx library', () => {
await zeroEx.setProviderAsync(newProvider);
// Check that contractInstances with old provider are removed after provider update
- expect((zeroEx.exchange as any)._exchangeContractIfExists).to.be.undefined();
+ 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
@@ -52,6 +53,10 @@ describe('ZeroEx library', () => {
const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
const web3 = web3Factory.create();
const zeroEx = new ZeroEx(web3.currentProvider);
+ let exchangeContractAddress: string;
+ before(async () => {
+ [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
+ });
it('should return false if the data doesn\'t pertain to the signature & address', async () => {
expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
return expect(
@@ -77,7 +82,7 @@ describe('ZeroEx library', () => {
const isValidSignatureLocal = ZeroEx.isValidSignature(dataHex, signature, address);
expect(isValidSignatureLocal).to.be.true();
const isValidSignatureOnContract = await (zeroEx.exchange as any)
- ._isValidSignatureUsingContractCallAsync(dataHex, signature, address);
+ ._isValidSignatureUsingContractCallAsync(dataHex, signature, address, exchangeContractAddress);
return expect(isValidSignatureOnContract).to.be.true();
});
});
@@ -125,15 +130,16 @@ describe('ZeroEx library', () => {
expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount);
});
});
- describe('#getOrderHashHexAsync', () => {
- const exchangeContractAddress = constants.NULL_ADDRESS;
- const expectedOrderHash = '0x103a5e97dab5dbeb8f385636f86a7d1e458a7ccbe1bd194727f0b2f85ab116c7';
+ describe('#getOrderHashHex', () => {
+ const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
+ const fakeExchangeContractAddress = '0xb69e673309512a9d726f87304c6984054f87a93b';
const order: Order = {
maker: constants.NULL_ADDRESS,
taker: constants.NULL_ADDRESS,
feeRecipient: constants.NULL_ADDRESS,
makerTokenAddress: constants.NULL_ADDRESS,
takerTokenAddress: constants.NULL_ADDRESS,
+ exchangeContractAddress: fakeExchangeContractAddress,
salt: new BigNumber(0),
makerFee: new BigNumber(0),
takerFee: new BigNumber(0),
@@ -141,22 +147,11 @@ describe('ZeroEx library', () => {
takerTokenAmount: new BigNumber(0),
expirationUnixTimestampSec: new BigNumber(0),
};
- let stubs: Sinon.SinonStub[] = [];
- afterEach(() => {
- // clean up any stubs after the test has completed
- _.each(stubs, s => s.restore());
- stubs = [];
- });
it('calculates the order hash', async () => {
const web3 = web3Factory.create();
const zeroEx = new ZeroEx(web3.currentProvider);
- stubs = [
- Sinon.stub((zeroEx as any), '_getExchangeAddressAsync')
- .returns(Promise.resolve(exchangeContractAddress)),
- ];
-
- const orderHash = await zeroEx.getOrderHashHexAsync(order);
+ const orderHash = zeroEx.getOrderHashHex(order);
expect(orderHash).to.be.equal(expectedOrderHash);
});
});
diff --git a/test/artifacts_test.ts b/test/artifacts_test.ts
index d71b45567..22d55a2ee 100644
--- a/test/artifacts_test.ts
+++ b/test/artifacts_test.ts
@@ -1,9 +1,14 @@
import * as fs from 'fs';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
import HDWalletProvider = require('truffle-hdwallet-provider');
import {ZeroEx} from '../src';
import {web3Factory} from './utils/web3_factory';
import {constants} from './utils/constants';
+chaiSetup.configure();
+const expect = chai.expect;
+
// Those tests are slower cause they're talking to a remote node
const TIMEOUT = 10000;
@@ -22,7 +27,8 @@ describe('Artifacts', () => {
await (zeroEx.token as any)._getProxyAddressAsync();
}).timeout(TIMEOUT);
it('exchange contract is deployed', async () => {
- await (zeroEx.exchange as any)._getExchangeContractAsync();
+ const exchangeContractAddresses = await zeroEx.exchange.getAvailableContractAddressesAsync();
+ expect(exchangeContractAddresses).to.have.lengthOf.above(0);
}).timeout(TIMEOUT);
});
});
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index 7835de993..873ff48db 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -1,4 +1,5 @@
import 'mocha';
+import * as _ from 'lodash';
import * as chai from 'chai';
import * as Web3 from 'web3';
import * as BigNumber from 'bignumber.js';
@@ -23,6 +24,7 @@ import {DoneCallback} from '../src/types';
import {FillScenarios} from './utils/fill_scenarios';
import {TokenUtils} from './utils/token_utils';
import {assert} from '../src/utils/assert';
+import {ProxyWrapper} from '../src/contract_wrappers/proxy_wrapper';
chaiSetup.configure();
const expect = chai.expect;
@@ -38,14 +40,16 @@ describe('ExchangeWrapper', () => {
let userAddresses: string[];
let zrxTokenAddress: string;
let fillScenarios: FillScenarios;
+ let exchangeContractAddress: string;
before(async () => {
web3 = web3Factory.create();
zeroEx = new ZeroEx(web3.currentProvider);
+ [exchangeContractAddress] = await zeroEx.exchange.getAvailableContractAddressesAsync();
userAddresses = await promisify(web3.eth.getAccounts)();
tokens = await zeroEx.tokenRegistry.getTokensAsync();
tokenUtils = new TokenUtils(tokens);
zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
- fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress);
+ fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
});
beforeEach(async () => {
await blockchainLifecycle.startAsync();
@@ -392,11 +396,11 @@ describe('ExchangeWrapper', () => {
signedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- signedOrderHashHex = await zeroEx.getOrderHashHexAsync(signedOrder);
+ signedOrderHashHex = zeroEx.getOrderHashHex(signedOrder);
anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- anotherOrderHashHex = await zeroEx.getOrderHashHexAsync(anotherSignedOrder);
+ anotherOrderHashHex = zeroEx.getOrderHashHex(anotherSignedOrder);
orderFillBatch = [
{
signedOrder,
@@ -414,8 +418,12 @@ describe('ExchangeWrapper', () => {
});
it('should successfully fill multiple orders', async () => {
await zeroEx.exchange.batchFillOrderAsync(orderFillBatch, shouldCheckTransfer, takerAddress);
- const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
- const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+ const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(
+ signedOrderHashHex, exchangeContractAddress,
+ );
+ const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(
+ anotherOrderHashHex, exchangeContractAddress,
+ );
expect(filledAmount).to.be.bignumber.equal(fillTakerAmount);
expect(anotherFilledAmount).to.be.bignumber.equal(fillTakerAmount);
});
@@ -432,11 +440,11 @@ describe('ExchangeWrapper', () => {
signedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- signedOrderHashHex = await zeroEx.getOrderHashHexAsync(signedOrder);
+ signedOrderHashHex = zeroEx.getOrderHashHex(signedOrder);
anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- anotherOrderHashHex = await zeroEx.getOrderHashHexAsync(anotherSignedOrder);
+ anotherOrderHashHex = zeroEx.getOrderHashHex(anotherSignedOrder);
signedOrders = [signedOrder, anotherSignedOrder];
});
describe('successful batch fills', () => {
@@ -447,8 +455,12 @@ describe('ExchangeWrapper', () => {
await zeroEx.exchange.fillOrdersUpToAsync(
signedOrders, fillUpToAmount, shouldCheckTransfer, takerAddress,
);
- const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
- const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+ const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(
+ signedOrderHashHex, exchangeContractAddress,
+ );
+ const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(
+ anotherOrderHashHex, exchangeContractAddress,
+ );
expect(filledAmount).to.be.bignumber.equal(fillableAmount);
const remainingFillAmount = fillableAmount.minus(1);
expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
@@ -480,7 +492,7 @@ describe('ExchangeWrapper', () => {
signedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- orderHashHex = await zeroEx.getOrderHashHexAsync(signedOrder);
+ orderHashHex = zeroEx.getOrderHashHex(signedOrder);
});
describe('#cancelOrderAsync', () => {
describe('failed cancels', () => {
@@ -495,7 +507,7 @@ describe('ExchangeWrapper', () => {
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
fillableAmount, expirationInPast,
);
- orderHashHex = await zeroEx.getOrderHashHexAsync(expiredSignedOrder);
+ orderHashHex = zeroEx.getOrderHashHex(expiredSignedOrder);
return expect(zeroEx.exchange.cancelOrderAsync(expiredSignedOrder, cancelAmount))
.to.be.rejectedWith(ExchangeContractErrs.ORDER_CANCEL_EXPIRED);
});
@@ -508,7 +520,9 @@ describe('ExchangeWrapper', () => {
describe('successful cancels', () => {
it('should cancel an order', async () => {
await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
- const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHashHex);
+ const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(
+ orderHashHex, exchangeContractAddress,
+ );
expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
});
it('should return cancelled amount', async () => {
@@ -525,7 +539,7 @@ describe('ExchangeWrapper', () => {
anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- anotherOrderHashHex = await zeroEx.getOrderHashHexAsync(anotherSignedOrder);
+ anotherOrderHashHex = zeroEx.getOrderHashHex(anotherSignedOrder);
cancelBatch = [
{
order: signedOrder,
@@ -554,9 +568,12 @@ describe('ExchangeWrapper', () => {
describe('successful batch cancels', () => {
it('should cancel a batch of orders', async () => {
await zeroEx.exchange.batchCancelOrderAsync(cancelBatch);
- const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHashHex);
+ const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(
+ orderHashHex, exchangeContractAddress,
+ );
const anotherCancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(
- anotherOrderHashHex);
+ anotherOrderHashHex, exchangeContractAddress,
+ );
expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
expect(anotherCancelledAmount).to.be.bignumber.equal(cancelAmount);
});
@@ -583,53 +600,73 @@ describe('ExchangeWrapper', () => {
signedOrder = await fillScenarios.createPartiallyFilledSignedOrderAsync(
makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount, partialFillAmount,
);
- orderHash = await zeroEx.getOrderHashHexAsync(signedOrder);
+ orderHash = zeroEx.getOrderHashHex(signedOrder);
});
describe('#getUnavailableTakerAmountAsync', () => {
it ('should throw if passed an invalid orderHash', async () => {
const invalidOrderHashHex = '0x123';
- return expect(zeroEx.exchange.getUnavailableTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+ return expect(zeroEx.exchange.getUnavailableTakerAmountAsync(
+ invalidOrderHashHex, exchangeContractAddress,
+ )).to.be.rejected();
});
it ('should return zero if passed a valid but non-existent orderHash', async () => {
- const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+ const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(
+ NON_EXISTENT_ORDER_HASH, exchangeContractAddress,
+ );
expect(unavailableValueT).to.be.bignumber.equal(0);
});
it ('should return the unavailableValueT for a valid and partially filled orderHash', async () => {
- const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(orderHash);
+ const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(
+ orderHash, exchangeContractAddress,
+ );
expect(unavailableValueT).to.be.bignumber.equal(partialFillAmount);
});
});
describe('#getFilledTakerAmountAsync', () => {
it ('should throw if passed an invalid orderHash', async () => {
const invalidOrderHashHex = '0x123';
- return expect(zeroEx.exchange.getFilledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+ return expect(zeroEx.exchange.getFilledTakerAmountAsync(
+ invalidOrderHashHex, exchangeContractAddress,
+ )).to.be.rejected();
});
it ('should return zero if passed a valid but non-existent orderHash', async () => {
- const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+ const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(
+ NON_EXISTENT_ORDER_HASH, exchangeContractAddress,
+ );
expect(filledValueT).to.be.bignumber.equal(0);
});
it ('should return the filledValueT for a valid and partially filled orderHash', async () => {
- const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(orderHash);
+ const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(
+ orderHash, exchangeContractAddress,
+ );
expect(filledValueT).to.be.bignumber.equal(partialFillAmount);
});
});
describe('#getCanceledTakerAmountAsync', () => {
it ('should throw if passed an invalid orderHash', async () => {
const invalidOrderHashHex = '0x123';
- return expect(zeroEx.exchange.getCanceledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+ return expect(zeroEx.exchange.getCanceledTakerAmountAsync(
+ invalidOrderHashHex, exchangeContractAddress,
+ )).to.be.rejected();
});
it ('should return zero if passed a valid but non-existent orderHash', async () => {
- const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+ const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(
+ NON_EXISTENT_ORDER_HASH, exchangeContractAddress,
+ );
expect(cancelledValueT).to.be.bignumber.equal(0);
});
it ('should return the cancelledValueT for a valid and partially filled orderHash', async () => {
- const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHash);
+ const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(
+ orderHash, exchangeContractAddress,
+ );
expect(cancelledValueT).to.be.bignumber.equal(0);
});
it ('should return the cancelledValueT for a valid and cancelled orderHash', async () => {
const cancelAmount = fillableAmount.minus(partialFillAmount);
await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
- const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHash);
+ const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(
+ orderHash, exchangeContractAddress,
+ );
expect(cancelledValueT).to.be.bignumber.equal(cancelAmount);
});
});
@@ -672,11 +709,13 @@ describe('ExchangeWrapper', () => {
// Source: https://github.com/mochajs/mocha/issues/2407
it('Should receive the LogFill event when an order is filled', (done: DoneCallback) => {
(async () => {
- const zeroExEvent = await zeroEx.exchange.subscribeAsync(ExchangeEvents.LogFill, subscriptionOpts,
- indexFilterValues);
+ const zeroExEvent = await zeroEx.exchange.subscribeAsync(
+ ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues, exchangeContractAddress,
+ );
zeroExEvent.watch((err: Error, event: ContractEvent) => {
expect(err).to.be.null();
expect(event).to.not.be.undefined();
+ expect(event.event).to.be.equal('LogFill');
done();
});
await zeroEx.exchange.fillOrderAsync(
@@ -686,11 +725,13 @@ describe('ExchangeWrapper', () => {
});
it('Should receive the LogCancel event when an order is cancelled', (done: DoneCallback) => {
(async () => {
- const zeroExEvent = await zeroEx.exchange.subscribeAsync(ExchangeEvents.LogCancel, subscriptionOpts,
- indexFilterValues);
+ const zeroExEvent = await zeroEx.exchange.subscribeAsync(
+ ExchangeEvents.LogCancel, subscriptionOpts, indexFilterValues, exchangeContractAddress,
+ );
zeroExEvent.watch((err: Error, event: ContractEvent) => {
expect(err).to.be.null();
expect(event).to.not.be.undefined();
+ expect(event.event).to.be.equal('LogCancel');
done();
});
await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelTakerAmountInBaseUnits);
@@ -699,7 +740,7 @@ describe('ExchangeWrapper', () => {
it('Outstanding subscriptions are cancelled when zeroEx.setProviderAsync called', (done: DoneCallback) => {
(async () => {
const eventSubscriptionToBeCancelled = await zeroEx.exchange.subscribeAsync(
- ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues,
+ ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues, exchangeContractAddress,
);
eventSubscriptionToBeCancelled.watch((err: Error, event: ContractEvent) => {
done(new Error('Expected this subscription to have been cancelled'));
@@ -709,11 +750,12 @@ describe('ExchangeWrapper', () => {
await zeroEx.setProviderAsync(newProvider);
const eventSubscriptionToStay = await zeroEx.exchange.subscribeAsync(
- ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues,
+ ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues, exchangeContractAddress,
);
eventSubscriptionToStay.watch((err: Error, event: ContractEvent) => {
expect(err).to.be.null();
expect(event).to.not.be.undefined();
+ expect(event.event).to.be.equal('LogFill');
done();
});
await zeroEx.exchange.fillOrderAsync(
@@ -724,7 +766,7 @@ describe('ExchangeWrapper', () => {
it('Should stop watch for events when stopWatchingAsync called on the eventEmitter', (done: DoneCallback) => {
(async () => {
const eventSubscriptionToBeStopped = await zeroEx.exchange.subscribeAsync(
- ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues,
+ ExchangeEvents.LogFill, subscriptionOpts, indexFilterValues, exchangeContractAddress,
);
eventSubscriptionToBeStopped.watch((err: Error, event: ContractEvent) => {
done(new Error('Expected this subscription to have been stopped'));
@@ -770,16 +812,29 @@ describe('ExchangeWrapper', () => {
const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
- const orderHash = await zeroEx.getOrderHashHexAsync(signedOrder);
+ const orderHash = zeroEx.getOrderHashHex(signedOrder);
const orderHashFromContract = await (zeroEx.exchange as any)
._getOrderHashHexUsingContractCallAsync(signedOrder);
expect(orderHash).to.equal(orderHashFromContract);
});
});
- describe('#getContractAddressAsync', () => {
- it('returns the exchange contract address', async () => {
- const exchangeAddress = await zeroEx.exchange.getContractAddressAsync();
- assert.isETHAddressHex('exchangeAddress', exchangeAddress);
+ 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 proxyWrapper = (zeroEx as any)._proxyWrapper as ProxyWrapper;
+ const isAuthorized = await proxyWrapper.isAuthorizedAsync(exchangeAddress);
+ expect(isAuthorized).to.be.true();
+ }
});
});
});
diff --git a/test/proxy_wrapper_test.ts b/test/proxy_wrapper_test.ts
new file mode 100644
index 000000000..29b5776c6
--- /dev/null
+++ b/test/proxy_wrapper_test.ts
@@ -0,0 +1,23 @@
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx} from '../src';
+import {ProxyWrapper} from '../src/contract_wrappers/proxy_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('ProxyWrapper', () => {
+ let zeroEx: ZeroEx;
+ before(async () => {
+ const web3 = web3Factory.create();
+ zeroEx = new ZeroEx(web3.currentProvider);
+ });
+ describe('#isAuthorizedAsync', () => {
+ it('should return false if the address is not authorized', async () => {
+ const proxyWrapper = (zeroEx as any)._proxyWrapper as ProxyWrapper;
+ const isAuthorized = await proxyWrapper.isAuthorizedAsync(ZeroEx.NULL_ADDRESS);
+ expect(isAuthorized).to.be.false();
+ });
+ });
+});
diff --git a/test/utils/fill_scenarios.ts b/test/utils/fill_scenarios.ts
index b8ad7eb12..65a912955 100644
--- a/test/utils/fill_scenarios.ts
+++ b/test/utils/fill_scenarios.ts
@@ -9,12 +9,15 @@ export class FillScenarios {
private tokens: Token[];
private coinbase: string;
private zrxTokenAddress: string;
- constructor(zeroEx: ZeroEx, userAddresses: string[], tokens: Token[], zrxTokenAddress: string) {
+ private exchangeContractAddress: string;
+ constructor(zeroEx: ZeroEx, userAddresses: string[],
+ tokens: Token[], zrxTokenAddress: string, exchangeContractAddress: string) {
this.zeroEx = zeroEx;
this.userAddresses = userAddresses;
this.tokens = tokens;
this.coinbase = userAddresses[0];
this.zrxTokenAddress = zrxTokenAddress;
+ this.exchangeContractAddress = exchangeContractAddress;
}
public async createFillableSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
makerAddress: string, takerAddress: string,
@@ -103,7 +106,7 @@ export class FillScenarios {
const signedOrder = await orderFactory.createSignedOrderAsync(this.zeroEx,
makerAddress, takerAddress, makerFee, takerFee,
makerFillableAmount, makerTokenAddress, takerFillableAmount, takerTokenAddress,
- feeRecepient, expirationUnixTimestampSec);
+ this.exchangeContractAddress, feeRecepient, expirationUnixTimestampSec);
return signedOrder;
}
}
diff --git a/test/utils/order_factory.ts b/test/utils/order_factory.ts
index ef19f2c4c..22bf44c0f 100644
--- a/test/utils/order_factory.ts
+++ b/test/utils/order_factory.ts
@@ -13,6 +13,7 @@ export const orderFactory = {
makerTokenAddress: string,
takerTokenAmount: BigNumber.BigNumber,
takerTokenAddress: string,
+ exchangeContractAddress: string,
feeRecipient: string,
expirationUnixTimestampSec?: BigNumber.BigNumber): Promise<SignedOrder> {
const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
@@ -29,10 +30,11 @@ export const orderFactory = {
makerTokenAddress,
takerTokenAddress,
salt: ZeroEx.generatePseudoRandomSalt(),
+ exchangeContractAddress,
feeRecipient,
expirationUnixTimestampSec,
};
- const orderHash = await zeroEx.getOrderHashHexAsync(order);
+ const orderHash = zeroEx.getOrderHashHex(order);
const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker);
const signedOrder: SignedOrder = _.assign(order, {ecSignature});
return signedOrder;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 03:59:15 +0800