crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor to use OrderCancellationRequest

Browse Source
This commit is contained in:
Leonid Logvinov 2017-06-07 14:40:28 +02:00
parent 91101eb8ec
commit c3cd5812e6
No known key found for this signature in database
GPG Key ID: 0DD294BFDE8C95D4
4 changed files with 45 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/contract_wrappers/exchange_wrapper.ts
View File

@ -18,7 +18,7 @@ import {
CreateContractEvent,
ContractEventObj,
EventCallback,
ContractResponse,
ContractResponse, OrderCancellationRequest,
} from '../types';
import {assert} from '../utils/assert';
import {utils} from '../utils/utils';
@ -208,29 +208,31 @@ export class ExchangeWrapper extends ContractWrapper {
/**
* Batch version of cancelOrderAsync. Atomically cancels multiple orders in a single transaction.
*/
public async batchCancelOrderAsync(
orders: Array<Order|SignedOrder>, takerTokenCancelAmounts: BigNumber.BigNumber[]): Promise<void> {
const makers = _.map(orders, order => order.maker);
assert.isSameLength('orders', orders, 'takerTokenCancelAmounts', takerTokenCancelAmounts);
assert.assert(!_.isEmpty(orders), 'Can not cancel an empty batch');
public async batchCancelOrderAsync(cancellationRequestsBatch: OrderCancellationRequest[]): Promise<void> {
const makers = _.map(cancellationRequestsBatch, cancellationRequest => cancellationRequest.order.maker);
assert.assert(!_.isEmpty(cancellationRequestsBatch), 'Can not cancel an empty batch');
assert.assert(_.uniq(makers).length === 1, 'Can not cancel orders from multiple makers in a single batch');
const maker = makers[0];
// _.zip doesn't type check if values have different types :'(
const ordersAndTakerTokenCancelAmounts = _.zip<any>(orders, takerTokenCancelAmounts);
_.forEach(ordersAndTakerTokenCancelAmounts,
async ([order, takerTokenCancelAmount]: [Order|SignedOrder, BigNumber.BigNumber]) => {
_.forEach(cancellationRequestsBatch,
async (cancellationRequest: OrderCancellationRequest) => {
assert.doesConformToSchema('order',
SchemaValidator.convertToJSONSchemaCompatibleObject(order as object), orderSchema);
assert.isBigNumber('takerTokenCancelAmount', takerTokenCancelAmount);
await assert.isSenderAddressAvailableAsync(this.web3Wrapper, 'order.maker', order.maker);
await this.validateCancelOrderAndThrowIfInvalidAsync(order, takerTokenCancelAmount);
SchemaValidator.convertToJSONSchemaCompatibleObject(cancellationRequest.order as object), orderSchema);
assert.isBigNumber('takerTokenCancelAmount', cancellationRequest.takerTokenCancelAmount);
await assert.isSenderAddressAvailableAsync(this.web3Wrapper, 'order.maker',
cancellationRequest.order.maker);
await this.validateCancelOrderAndThrowIfInvalidAsync(
cancellationRequest.order, cancellationRequest.takerTokenCancelAmount);
});
const exchangeInstance = await this.getExchangeContractAsync();
const orderAddressesAndValues = _.map(orders, order => {
return ExchangeWrapper.getOrderAddressesAndValues(order);
const orderAddressesValuesAndTakerTokenCancelAmounts = _.map(cancellationRequestsBatch, cancellationRequest => {
return [
...ExchangeWrapper.getOrderAddressesAndValues(cancellationRequest.order),
cancellationRequest.takerTokenCancelAmount,
];
});
// _.unzip doesn't type check if values have different types :'(
const [orderAddresses, orderValues] = _.unzip<any>(orderAddressesAndValues);
const [orderAddresses, orderValues, takerTokenCancelAmounts] =
_.unzip<any>(orderAddressesValuesAndTakerTokenCancelAmounts);
const gas = await exchangeInstance.batchCancel.estimateGas(
orderAddresses,
orderValues,

5
src/types.ts
View File

@ -222,3 +222,8 @@ export interface SubscriptionOpts {
}
export type DoneCallback = (err?: Error) => void;
export interface OrderCancellationRequest {
order: Order|SignedOrder;
takerTokenCancelAmount: BigNumber.BigNumber;
}

6
src/utils/assert.ts
View File

@ -42,12 +42,6 @@ export const assert = {
const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 instance');
},
isSameLength(variableName1: string, value1: any[], variableName2: string, value2: any[]) {
const length1 = value1.length;
const length2 = value2.length;
this.assert(length1 === length2, `${variableName1} and ${variableName2} length mismatch. \
${length1} != ${length2}`);
},
isNumber(variableName: string, value: number): void {
this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
},

32
test/exchange_wrapper_test.ts
View File

@ -16,7 +16,7 @@ import {
ExchangeEvents,
ContractEvent,
DoneCallback,
ExchangeContractErrs,
ExchangeContractErrs, OrderCancellationRequest,
} from '../src/types';
import {FillScenarios} from './utils/fill_scenarios';
import {TokenUtils} from './utils/token_utils';
@ -377,34 +377,44 @@ describe('ExchangeWrapper', () => {
describe('#batchCancelOrderAsync', () => {
let anotherSignedOrder: SignedOrder;
let anotherOrderHashHex: string;
let cancelBatch: OrderCancellationRequest[];
beforeEach(async () => {
anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
);
anotherOrderHashHex = await zeroEx.getOrderHashHexAsync(anotherSignedOrder);
cancelBatch = [
{
order: signedOrder,
takerTokenCancelAmount: cancelAmount,
},
{
order: anotherSignedOrder,
takerTokenCancelAmount: cancelAmount,
},
];
});
describe('failed batch cancels', () => {
it('should throw when length of orders and cancelAmounts mismatch', async () => {
return expect(zeroEx.exchange.batchCancelOrderAsync([signedOrder], []))
.to.be.rejectedWith('orders and takerTokenCancelAmounts length mismatch. 1 != 0');
});
it('should throw when orders are empty', async () => {
return expect(zeroEx.exchange.batchCancelOrderAsync([], []))
return expect(zeroEx.exchange.batchCancelOrderAsync([]))
.to.be.rejectedWith('Can not cancel an empty batch');
});
it.only('should throw when orders have different makers', async () => {
const signedOrderWithADifferentMaker = await fillScenarios.createFillableSignedOrderAsync(
makerTokenAddress, takerTokenAddress, takerAddress, takerAddress, fillableAmount,
);
return expect(zeroEx.exchange.batchCancelOrderAsync(
[signedOrder, signedOrderWithADifferentMaker], [cancelAmount, cancelAmount]))
.to.be.rejectedWith('Can not cancel orders from multiple makers in a single batch');
return expect(zeroEx.exchange.batchCancelOrderAsync([
cancelBatch[0],
{
order: signedOrderWithADifferentMaker,
takerTokenCancelAmount: cancelAmount,
},
])).to.be.rejectedWith('Can not cancel orders from multiple makers in a single batch');
});
});
describe('successful batch cancels', () => {
it('should cancel a batch of orders', async () => {
await zeroEx.exchange.batchCancelOrderAsync(
[signedOrder, anotherSignedOrder], [cancelAmount, cancelAmount]);
await zeroEx.exchange.batchCancelOrderAsync(cancelBatch);
const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHashHex);
const anotherCancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(
anotherOrderHashHex);