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

Remove getOrdersInfo

Browse Source
This commit is contained in:
Amir Bandeali
2019-09-01 11:24:16 -07:00
parent 8410ee9d2f
commit b888e48a30
5 changed files with 0 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
contracts/exchange/contracts/src/MixinWrapperFunctions.sol
View File

@@ -341,22 +341,6 @@ contract MixinWrapperFunctions is
}
}
/// @dev Fetches information for all passed in orders.
/// @param orders Array of order specifications.
/// @return Array of OrderInfo instances that correspond to each order.
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory)
{
uint256 ordersLength = orders.length;
LibOrder.OrderInfo[] memory ordersInfo = new LibOrder.OrderInfo[](ordersLength);
for (uint256 i = 0; i != ordersLength; i++) {
ordersInfo[i] = getOrderInfo(orders[i]);
}
return ordersInfo;
}
/// @dev Fills the input order. Reverts if exact takerAssetFillAmount not filled.
/// @param order Order struct containing order specifications.
/// @param takerAssetFillAmount Desired amount of takerAsset to sell.

8
contracts/exchange/contracts/src/interfaces/IWrapperFunctions.sol
View File

@@ -157,12 +157,4 @@ contract IWrapperFunctions {
function batchCancelOrders(LibOrder.Order[] memory orders)
public
payable;
/// @dev Fetches information for all passed in orders
/// @param orders Array of order specifications.
/// @return Array of OrderInfo instances that correspond to each order.
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory);
}

4
contracts/exchange/test/utils/exchange_wrapper.ts
View File

@@ -215,10 +215,6 @@ export class ExchangeWrapper {
const orderInfo = await this._exchange.getOrderInfo.callAsync(signedOrder);
return orderInfo;
}
public async getOrdersInfoAsync(signedOrders: SignedOrder[]): Promise<OrderInfo[]> {
const ordersInfo = (await this._exchange.getOrdersInfo.callAsync(signedOrders)) as OrderInfo[];
return ordersInfo;
}
public async batchMatchOrdersAsync(
signedOrdersLeft: SignedOrder[],
signedOrdersRight: SignedOrder[],

184
contracts/exchange/test/wrapper.ts
View File

@@ -1173,189 +1173,5 @@ blockchainTests.resets('Exchange wrappers', env => {
});
});
});
describe('getOrdersInfo', () => {
beforeEach(async () => {
signedOrders = [
await orderFactory.newSignedOrderAsync(),
await orderFactory.newSignedOrderAsync(),
await orderFactory.newSignedOrderAsync(),
];
});
it('should get the correct information for multiple unfilled orders', async () => {
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.Fillable;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple partially filled orders', async () => {
const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.Fillable;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple fully filled orders', async () => {
await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress);
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
const expectedOrderStatus = OrderStatus.FullyFilled;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple cancelled and unfilled orders', async () => {
await exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.Cancelled;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple cancelled and partially filled orders', async () => {
const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
await exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.Cancelled;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple expired and unfilled orders', async () => {
const currentTimestamp = await getLatestBlockTimestampAsync();
const timeUntilExpiration = signedOrders[0].expirationTimeSeconds.minus(currentTimestamp).toNumber();
await increaseTimeAndMineBlockAsync(timeUntilExpiration);
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.Expired;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for multiple expired and partially filled orders', async () => {
const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
const currentTimestamp = await getLatestBlockTimestampAsync();
const timeUntilExpiration = signedOrders[0].expirationTimeSeconds.minus(currentTimestamp).toNumber();
await increaseTimeAndMineBlockAsync(timeUntilExpiration);
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(3);
_.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.Expired;
const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
});
});
it('should get the correct information for a mix of unfilled, partially filled, fully filled, cancelled, and expired orders', async () => {
const unfilledOrder = await orderFactory.newSignedOrderAsync();
const partiallyFilledOrder = await orderFactory.newSignedOrderAsync();
await exchangeWrapper.fillOrderAsync(partiallyFilledOrder, takerAddress, {
takerAssetFillAmount: partiallyFilledOrder.takerAssetAmount.div(2),
});
const fullyFilledOrder = await orderFactory.newSignedOrderAsync();
await exchangeWrapper.fillOrderAsync(fullyFilledOrder, takerAddress);
const cancelledOrder = await orderFactory.newSignedOrderAsync();
await exchangeWrapper.cancelOrderAsync(cancelledOrder, makerAddress);
const currentTimestamp = await getLatestBlockTimestampAsync();
const expiredOrder = await orderFactory.newSignedOrderAsync({
expirationTimeSeconds: new BigNumber(currentTimestamp),
});
signedOrders = [unfilledOrder, partiallyFilledOrder, fullyFilledOrder, cancelledOrder, expiredOrder];
const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
expect(ordersInfo.length).to.be.equal(5);
const expectedUnfilledOrderHash = orderHashUtils.getOrderHashHex(unfilledOrder);
const expectedUnfilledTakerAssetFilledAmount = new BigNumber(0);
const expectedUnfilledOrderStatus = OrderStatus.Fillable;
const unfilledOrderInfo = ordersInfo[0];
expect(unfilledOrderInfo.orderHash).to.be.equal(expectedUnfilledOrderHash);
expect(unfilledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
expectedUnfilledTakerAssetFilledAmount,
);
expect(unfilledOrderInfo.orderStatus).to.be.equal(expectedUnfilledOrderStatus);
const expectedPartialOrderHash = orderHashUtils.getOrderHashHex(partiallyFilledOrder);
const expectedPartialTakerAssetFilledAmount = partiallyFilledOrder.takerAssetAmount.div(2);
const expectedPartialOrderStatus = OrderStatus.Fillable;
const partialOrderInfo = ordersInfo[1];
expect(partialOrderInfo.orderHash).to.be.equal(expectedPartialOrderHash);
expect(partialOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
expectedPartialTakerAssetFilledAmount,
);
expect(partialOrderInfo.orderStatus).to.be.equal(expectedPartialOrderStatus);
const expectedFilledOrderHash = orderHashUtils.getOrderHashHex(fullyFilledOrder);
const expectedFilledTakerAssetFilledAmount = fullyFilledOrder.takerAssetAmount;
const expectedFilledOrderStatus = OrderStatus.FullyFilled;
const filledOrderInfo = ordersInfo[2];
expect(filledOrderInfo.orderHash).to.be.equal(expectedFilledOrderHash);
expect(filledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
expectedFilledTakerAssetFilledAmount,
);
expect(filledOrderInfo.orderStatus).to.be.equal(expectedFilledOrderStatus);
const expectedCancelledOrderHash = orderHashUtils.getOrderHashHex(cancelledOrder);
const expectedCancelledTakerAssetFilledAmount = new BigNumber(0);
const expectedCancelledOrderStatus = OrderStatus.Cancelled;
const cancelledOrderInfo = ordersInfo[3];
expect(cancelledOrderInfo.orderHash).to.be.equal(expectedCancelledOrderHash);
expect(cancelledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
expectedCancelledTakerAssetFilledAmount,
);
expect(cancelledOrderInfo.orderStatus).to.be.equal(expectedCancelledOrderStatus);
const expectedExpiredOrderHash = orderHashUtils.getOrderHashHex(expiredOrder);
const expectedExpiredTakerAssetFilledAmount = new BigNumber(0);
const expectedExpiredOrderStatus = OrderStatus.Expired;
const expiredOrderInfo = ordersInfo[4];
expect(expiredOrderInfo.orderHash).to.be.equal(expectedExpiredOrderHash);
expect(expiredOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
expectedExpiredTakerAssetFilledAmount,
);
expect(expiredOrderInfo.orderStatus).to.be.equal(expectedExpiredOrderStatus);
});
});
});
}); // tslint:disable-line:max-file-line-count

45
contracts/exchange/test/wrapper_unit_tests.ts
View File

@@ -1321,50 +1321,5 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
return expect(tx).to.revertWith(expectedError);
});
});
describe('getOrdersInfo', () => {
// Computes the expected (fake) order info generated by the `TestWrapperFunctions` contract.
function getExpectedOrderInfo(order: Order): OrderInfo {
const MAX_ORDER_STATUS = OrderStatus.Cancelled as number;
return {
orderHash: getExpectedOrderHash(order),
// Lower uint128 of `order.salt` is the `orderTakerAssetFilledAmount`.
orderTakerAssetFilledAmount: order.salt.mod(new BigNumber(2).pow(128)),
// High byte of `order.salt` is the `orderStatus`.
orderStatus:
order.salt.dividedToIntegerBy(new BigNumber(2).pow(248)).toNumber() % (MAX_ORDER_STATUS + 1),
};
}
it('works with no orders', async () => {
const infos = await testContract.getOrdersInfo.callAsync([]);
expect(infos.length).to.eq(0);
});
it('works with one order', async () => {
const orders = [randomOrder()];
const expectedResult = orders.map(getExpectedOrderInfo);
const actualResult = await testContract.getOrdersInfo.callAsync(orders);
expect(actualResult).to.deep.eq(expectedResult);
});
it('works with many orders', async () => {
const NUM_ORDERS = 16;
const orders = _.times(NUM_ORDERS, () => randomOrder());
const expectedResult = orders.map(getExpectedOrderInfo);
const actualResult = await testContract.getOrdersInfo.callAsync(orders);
expect(actualResult).to.deep.eq(expectedResult);
});
it('works with duplicate orders', async () => {
const NUM_UNIQUE_ORDERS = 4;
const CLONE_COUNT = 2;
const uniqueOrders = _.times(NUM_UNIQUE_ORDERS, () => randomOrder());
const orders = _.shuffle(_.flatten(_.times(CLONE_COUNT, () => uniqueOrders)));
const expectedResult = orders.map(getExpectedOrderInfo);
const actualResult = await testContract.getOrdersInfo.callAsync(orders);
expect(actualResult).to.deep.eq(expectedResult);
});
});
});
// tslint:disable-next-line: max-file-line-count