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

Implement tslint enum-naming to enforce PascalCase on enum members (#1474)

Browse Source
This commit is contained in:
Xianny
2019-01-11 10:04:30 -08:00
committed by GitHub
parent cf3787edbb
commit 943c378309
40 changed files with 523 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
contracts/extensions/test/extensions/balance_threshold_filter.ts
View File

@@ -1457,7 +1457,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
validSignedOrder, validSignedOrder,
); );
expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
// Cancel // Cancel
const txReceipt = await erc721MakerBalanceThresholdWrapper.cancelOrderAsync( const txReceipt = await erc721MakerBalanceThresholdWrapper.cancelOrderAsync(
validSignedOrder, validSignedOrder,
@@ -1470,7 +1470,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
validSignedOrder, validSignedOrder,
); );
expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
}); });
it('Should successfully cancel order if maker does not meet balance threshold', async () => { it('Should successfully cancel order if maker does not meet balance threshold', async () => {
// Create order where maker does not meet balance threshold // Create order where maker does not meet balance threshold
@@ -1479,7 +1479,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync(
signedOrderWithBadMakerAddress, signedOrderWithBadMakerAddress,
); );
expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
// Cancel // Cancel
const txReceipt = await erc721NonValidBalanceThresholdWrapper.cancelOrderAsync( const txReceipt = await erc721NonValidBalanceThresholdWrapper.cancelOrderAsync(
signedOrderWithBadMakerAddress, signedOrderWithBadMakerAddress,
@@ -1492,7 +1492,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
signedOrderWithBadMakerAddress, signedOrderWithBadMakerAddress,
); );
expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
}); });
}); });
@@ -1512,7 +1512,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
}); });
// Cancel // Cancel
const txReceipt = await erc721MakerBalanceThresholdWrapper.batchCancelOrdersAsync( const txReceipt = await erc721MakerBalanceThresholdWrapper.batchCancelOrdersAsync(
@@ -1527,7 +1527,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoAfterCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
}); });
}); });
it('Should successfully batch cancel order if maker does not meet balance threshold', async () => { it('Should successfully batch cancel order if maker does not meet balance threshold', async () => {
@@ -1542,7 +1542,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
}); });
// Cancel // Cancel
const txReceipt = await erc721NonValidBalanceThresholdWrapper.batchCancelOrdersAsync( const txReceipt = await erc721NonValidBalanceThresholdWrapper.batchCancelOrdersAsync(
@@ -1557,7 +1557,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoAfterCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoAfterCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
}); });
}); });
}); });
@@ -1578,7 +1578,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721MakerBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
}); });
// Cancel // Cancel
const cancelOrdersUpToThisSalt = new BigNumber(1); const cancelOrdersUpToThisSalt = new BigNumber(1);
@@ -1596,9 +1596,9 @@ describe(ContractName.BalanceThresholdFilter, () => {
); );
const saltAsBigNumber = new BigNumber(salt); const saltAsBigNumber = new BigNumber(salt);
if (saltAsBigNumber.lessThanOrEqualTo(cancelOrdersUpToThisSalt)) { if (saltAsBigNumber.lessThanOrEqualTo(cancelOrdersUpToThisSalt)) {
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
} else { } else {
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
} }
}); });
}); });
@@ -1614,7 +1614,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync( const orderInfoBeforeCancelling = await erc721NonValidBalanceThresholdWrapper.getOrderInfoAsync(
signedOrder, signedOrder,
); );
return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoBeforeCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
}); });
// Cancel // Cancel
const cancelOrdersUpToThisSalt = new BigNumber(1); const cancelOrdersUpToThisSalt = new BigNumber(1);
@@ -1632,9 +1632,9 @@ describe(ContractName.BalanceThresholdFilter, () => {
); );
const saltAsBigNumber = new BigNumber(salt); const saltAsBigNumber = new BigNumber(salt);
if (saltAsBigNumber.lessThanOrEqualTo(cancelOrdersUpToThisSalt)) { if (saltAsBigNumber.lessThanOrEqualTo(cancelOrdersUpToThisSalt)) {
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.CANCELLED); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Cancelled);
} else { } else {
return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.FILLABLE); return expect(orderInfoAfterCancelling.orderStatus).to.be.equal(OrderStatus.Fillable);
} }
}); });
}); });

12
contracts/extensions/test/extensions/order_validator.ts
View File

@@ -432,7 +432,7 @@ describe('OrderValidator', () => {
takerAddress, takerAddress,
); );
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
@@ -485,7 +485,7 @@ describe('OrderValidator', () => {
takerAddress, takerAddress,
); );
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance); expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance);
@@ -514,10 +514,10 @@ describe('OrderValidator', () => {
] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers); ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2); const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1); expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2); expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
@@ -581,10 +581,10 @@ describe('OrderValidator', () => {
] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers); ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2); const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1); expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2); expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT); expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance); expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance);

20
contracts/protocol/test/exchange/core.ts
View File

@@ -1043,7 +1043,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.FILLABLE; const expectedOrderStatus = OrderStatus.Fillable;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1053,7 +1053,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount; const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
const expectedOrderStatus = OrderStatus.FULLY_FILLED; const expectedOrderStatus = OrderStatus.FullyFilled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1064,7 +1064,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = takerAssetFillAmount; const expectedTakerAssetFilledAmount = takerAssetFillAmount;
const expectedOrderStatus = OrderStatus.FILLABLE; const expectedOrderStatus = OrderStatus.Fillable;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1074,7 +1074,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.CANCELLED; const expectedOrderStatus = OrderStatus.Cancelled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1086,7 +1086,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = takerAssetFillAmount; const expectedTakerAssetFilledAmount = takerAssetFillAmount;
const expectedOrderStatus = OrderStatus.CANCELLED; const expectedOrderStatus = OrderStatus.Cancelled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1098,7 +1098,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.EXPIRED; const expectedOrderStatus = OrderStatus.Expired;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1112,7 +1112,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = takerAssetFillAmount; const expectedTakerAssetFilledAmount = takerAssetFillAmount;
const expectedOrderStatus = OrderStatus.EXPIRED; const expectedOrderStatus = OrderStatus.Expired;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1126,7 +1126,7 @@ describe('Exchange core', () => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount; const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
// FULLY_FILLED takes precedence over EXPIRED // FULLY_FILLED takes precedence over EXPIRED
const expectedOrderStatus = OrderStatus.FULLY_FILLED; const expectedOrderStatus = OrderStatus.FullyFilled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1136,7 +1136,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.INVALID_MAKER_ASSET_AMOUNT; const expectedOrderStatus = OrderStatus.InvalidMakerAssetAmount;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1146,7 +1146,7 @@ describe('Exchange core', () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder); const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.INVALID_TAKER_ASSET_AMOUNT; const expectedOrderStatus = OrderStatus.InvalidTakerAssetAmount;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus); expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);

24
contracts/protocol/test/exchange/wrapper.ts
View File

@@ -1288,7 +1288,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.FILLABLE; const expectedOrderStatus = OrderStatus.Fillable;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1303,7 +1303,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2); const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.FILLABLE; const expectedOrderStatus = OrderStatus.Fillable;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1317,7 +1317,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount; const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
const expectedOrderStatus = OrderStatus.FULLY_FILLED; const expectedOrderStatus = OrderStatus.FullyFilled;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1331,7 +1331,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.CANCELLED; const expectedOrderStatus = OrderStatus.Cancelled;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1347,7 +1347,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2); const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.CANCELLED; const expectedOrderStatus = OrderStatus.Cancelled;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1363,7 +1363,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0); const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.EXPIRED; const expectedOrderStatus = OrderStatus.Expired;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1381,7 +1381,7 @@ describe('Exchange wrappers', () => {
_.forEach(signedOrders, (signedOrder, index) => { _.forEach(signedOrders, (signedOrder, index) => {
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder); const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2); const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
const expectedOrderStatus = OrderStatus.EXPIRED; const expectedOrderStatus = OrderStatus.Expired;
const orderInfo = ordersInfo[index]; const orderInfo = ordersInfo[index];
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash); expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount); expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1408,7 +1408,7 @@ describe('Exchange wrappers', () => {
const expectedUnfilledOrderHash = orderHashUtils.getOrderHashHex(unfilledOrder); const expectedUnfilledOrderHash = orderHashUtils.getOrderHashHex(unfilledOrder);
const expectedUnfilledTakerAssetFilledAmount = new BigNumber(0); const expectedUnfilledTakerAssetFilledAmount = new BigNumber(0);
const expectedUnfilledOrderStatus = OrderStatus.FILLABLE; const expectedUnfilledOrderStatus = OrderStatus.Fillable;
const unfilledOrderInfo = ordersInfo[0]; const unfilledOrderInfo = ordersInfo[0];
expect(unfilledOrderInfo.orderHash).to.be.equal(expectedUnfilledOrderHash); expect(unfilledOrderInfo.orderHash).to.be.equal(expectedUnfilledOrderHash);
expect(unfilledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal( expect(unfilledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1418,7 +1418,7 @@ describe('Exchange wrappers', () => {
const expectedPartialOrderHash = orderHashUtils.getOrderHashHex(partiallyFilledOrder); const expectedPartialOrderHash = orderHashUtils.getOrderHashHex(partiallyFilledOrder);
const expectedPartialTakerAssetFilledAmount = partiallyFilledOrder.takerAssetAmount.div(2); const expectedPartialTakerAssetFilledAmount = partiallyFilledOrder.takerAssetAmount.div(2);
const expectedPartialOrderStatus = OrderStatus.FILLABLE; const expectedPartialOrderStatus = OrderStatus.Fillable;
const partialOrderInfo = ordersInfo[1]; const partialOrderInfo = ordersInfo[1];
expect(partialOrderInfo.orderHash).to.be.equal(expectedPartialOrderHash); expect(partialOrderInfo.orderHash).to.be.equal(expectedPartialOrderHash);
expect(partialOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal( expect(partialOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1428,7 +1428,7 @@ describe('Exchange wrappers', () => {
const expectedFilledOrderHash = orderHashUtils.getOrderHashHex(fullyFilledOrder); const expectedFilledOrderHash = orderHashUtils.getOrderHashHex(fullyFilledOrder);
const expectedFilledTakerAssetFilledAmount = fullyFilledOrder.takerAssetAmount; const expectedFilledTakerAssetFilledAmount = fullyFilledOrder.takerAssetAmount;
const expectedFilledOrderStatus = OrderStatus.FULLY_FILLED; const expectedFilledOrderStatus = OrderStatus.FullyFilled;
const filledOrderInfo = ordersInfo[2]; const filledOrderInfo = ordersInfo[2];
expect(filledOrderInfo.orderHash).to.be.equal(expectedFilledOrderHash); expect(filledOrderInfo.orderHash).to.be.equal(expectedFilledOrderHash);
expect(filledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal( expect(filledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1438,7 +1438,7 @@ describe('Exchange wrappers', () => {
const expectedCancelledOrderHash = orderHashUtils.getOrderHashHex(cancelledOrder); const expectedCancelledOrderHash = orderHashUtils.getOrderHashHex(cancelledOrder);
const expectedCancelledTakerAssetFilledAmount = new BigNumber(0); const expectedCancelledTakerAssetFilledAmount = new BigNumber(0);
const expectedCancelledOrderStatus = OrderStatus.CANCELLED; const expectedCancelledOrderStatus = OrderStatus.Cancelled;
const cancelledOrderInfo = ordersInfo[3]; const cancelledOrderInfo = ordersInfo[3];
expect(cancelledOrderInfo.orderHash).to.be.equal(expectedCancelledOrderHash); expect(cancelledOrderInfo.orderHash).to.be.equal(expectedCancelledOrderHash);
expect(cancelledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal( expect(cancelledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1448,7 +1448,7 @@ describe('Exchange wrappers', () => {
const expectedExpiredOrderHash = orderHashUtils.getOrderHashHex(expiredOrder); const expectedExpiredOrderHash = orderHashUtils.getOrderHashHex(expiredOrder);
const expectedExpiredTakerAssetFilledAmount = new BigNumber(0); const expectedExpiredTakerAssetFilledAmount = new BigNumber(0);
const expectedExpiredOrderStatus = OrderStatus.EXPIRED; const expectedExpiredOrderStatus = OrderStatus.Expired;
const expiredOrderInfo = ordersInfo[4]; const expiredOrderInfo = ordersInfo[4];
expect(expiredOrderInfo.orderHash).to.be.equal(expectedExpiredOrderHash); expect(expiredOrderInfo.orderHash).to.be.equal(expectedExpiredOrderHash);
expect(expiredOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal( expect(expiredOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(

8
contracts/protocol/test/utils/match_order_tester.ts
View File

@@ -268,15 +268,15 @@ export class MatchOrderTester {
const maxAmountBoughtByLeftMaker = signedOrderLeft.takerAssetAmount.minus(initialLeftOrderFilledAmount); const maxAmountBoughtByLeftMaker = signedOrderLeft.takerAssetAmount.minus(initialLeftOrderFilledAmount);
const leftOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderLeft); const leftOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
const leftExpectedStatus = expectedTransferAmounts.amountBoughtByLeftMaker.equals(maxAmountBoughtByLeftMaker) const leftExpectedStatus = expectedTransferAmounts.amountBoughtByLeftMaker.equals(maxAmountBoughtByLeftMaker)
? OrderStatus.FULLY_FILLED ? OrderStatus.FullyFilled
: OrderStatus.FILLABLE; : OrderStatus.Fillable;
expect(leftOrderInfo.orderStatus, 'Checking exchange status for left order').to.be.equal(leftExpectedStatus); expect(leftOrderInfo.orderStatus, 'Checking exchange status for left order').to.be.equal(leftExpectedStatus);
// Assert right order status // Assert right order status
const maxAmountBoughtByRightMaker = signedOrderRight.takerAssetAmount.minus(initialRightOrderFilledAmount); const maxAmountBoughtByRightMaker = signedOrderRight.takerAssetAmount.minus(initialRightOrderFilledAmount);
const rightOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderRight); const rightOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderRight);
const rightExpectedStatus = expectedTransferAmounts.amountBoughtByRightMaker.equals(maxAmountBoughtByRightMaker) const rightExpectedStatus = expectedTransferAmounts.amountBoughtByRightMaker.equals(maxAmountBoughtByRightMaker)
? OrderStatus.FULLY_FILLED ? OrderStatus.FullyFilled
: OrderStatus.FILLABLE; : OrderStatus.Fillable;
expect(rightOrderInfo.orderStatus, 'Checking exchange status for right order').to.be.equal(rightExpectedStatus); expect(rightOrderInfo.orderStatus, 'Checking exchange status for right order').to.be.equal(rightExpectedStatus);
} }
/// @dev Asserts account balances after matching orders. /// @dev Asserts account balances after matching orders.

9
contracts/test-utils/CHANGELOG.json
View File

@@ -1,4 +1,13 @@
[ [
{
"version": "2.0.0",
"changes": [
{
"note": "Renamed OrderStatus enum members to PascalCase to conform with tslint enum-naming rule",
"pr": 1474
}
]
},
{ {
"timestamp": 1547225310, "timestamp": 1547225310,
"version": "1.0.4", "version": "1.0.4",

14
contracts/test-utils/src/types.ts
View File

@@ -70,13 +70,13 @@ export interface Token {
} }
export enum OrderStatus { export enum OrderStatus {
INVALID, Invalid,
INVALID_MAKER_ASSET_AMOUNT, InvalidMakerAssetAmount,
INVALID_TAKER_ASSET_AMOUNT, InvalidTakerAssetAmount,
FILLABLE, Fillable,
EXPIRED, Expired,
FULLY_FILLED, FullyFilled,
CANCELLED, Cancelled,
} }
export enum ContractName { export enum ContractName {

2
packages/asset-buyer/src/utils/order_provider_response_processor.ts
View File

@@ -105,7 +105,7 @@ function getValidOrdersWithRemainingFillableMakerAssetAmountsFromOnChain(
// get corresponding on-chain state for the order // get corresponding on-chain state for the order
const { orderInfo, traderInfo } = ordersAndTradersInfo[index]; const { orderInfo, traderInfo } = ordersAndTradersInfo[index];
// if the order IS NOT fillable, do not add anything to the accumulations and continue iterating // if the order IS NOT fillable, do not add anything to the accumulations and continue iterating
if (orderInfo.orderStatus !== OrderStatus.FILLABLE) { if (orderInfo.orderStatus !== OrderStatus.Fillable) {
return accOrders; return accOrders;
} }
// if the order IS fillable, add the order and calculate the remaining fillable amount // if the order IS fillable, add the order and calculate the remaining fillable amount

9
packages/contract-wrappers/CHANGELOG.json
View File

@@ -1,4 +1,13 @@
[ [
{
"version": "5.0.0",
"changes": [
{
"note": "Renamed OrderStatus enum members to PascalCase to conform with tslint enum-naming rule",
"pr": 1474
}
]
},
{ {
"timestamp": 1547225310, "timestamp": 1547225310,
"version": "4.2.1", "version": "4.2.1",

14
packages/contract-wrappers/src/types.ts
View File

@@ -177,13 +177,13 @@ export interface OrderInfo {
} }
export enum OrderStatus { export enum OrderStatus {
INVALID = 0, Invalid = 0,
INVALID_MAKER_ASSET_AMOUNT, InvalidMakerAssetAmount,
INVALID_TAKER_ASSET_AMOUNT, InvalidTakerAssetAmount,
FILLABLE, Fillable,
EXPIRED, Expired,
FULLY_FILLED, FullyFilled,
CANCELLED, Cancelled,
} }
export interface TraderInfo { export interface TraderInfo {

10
packages/contract-wrappers/test/exchange_wrapper_test.ts
View File

@@ -109,7 +109,7 @@ describe('ExchangeWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder); const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FullyFilled);
}); });
}); });
describe('#fillOrKillOrderAsync', () => { describe('#fillOrKillOrderAsync', () => {
@@ -157,7 +157,7 @@ describe('ExchangeWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder); const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FullyFilled);
}); });
}); });
describe('#marketSellOrdersAsync', () => { describe('#marketSellOrdersAsync', () => {
@@ -183,7 +183,7 @@ describe('ExchangeWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder); const orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FullyFilled);
}); });
}); });
describe('#batchFillOrdersNoThrowAsync', () => { describe('#batchFillOrdersNoThrowAsync', () => {
@@ -197,9 +197,9 @@ describe('ExchangeWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
let orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder); let orderInfo = await contractWrappers.exchange.getOrderInfoAsync(signedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FullyFilled);
orderInfo = await contractWrappers.exchange.getOrderInfoAsync(anotherSignedOrder); orderInfo = await contractWrappers.exchange.getOrderInfoAsync(anotherSignedOrder);
expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FullyFilled);
}); });
}); });
describe('#batchFillOrKillOrdersAsync', () => { describe('#batchFillOrKillOrdersAsync', () => {

8
packages/contract-wrappers/test/forwarder_wrapper_test.ts
View File

@@ -97,8 +97,8 @@ describe('ForwarderWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
const ordersInfo = await contractWrappers.exchange.getOrdersInfoAsync([signedOrder, anotherSignedOrder]); const ordersInfo = await contractWrappers.exchange.getOrdersInfoAsync([signedOrder, anotherSignedOrder]);
expect(ordersInfo[0].orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(ordersInfo[0].orderStatus).to.be.equal(OrderStatus.FullyFilled);
expect(ordersInfo[1].orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(ordersInfo[1].orderStatus).to.be.equal(OrderStatus.FullyFilled);
}); });
it('should throw when invalid transaction and shouldValidate is true', async () => { it('should throw when invalid transaction and shouldValidate is true', async () => {
const signedOrders = [signedOrder]; const signedOrders = [signedOrder];
@@ -131,8 +131,8 @@ describe('ForwarderWrapper', () => {
); );
await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS); await web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
const ordersInfo = await contractWrappers.exchange.getOrdersInfoAsync([signedOrder, anotherSignedOrder]); const ordersInfo = await contractWrappers.exchange.getOrdersInfoAsync([signedOrder, anotherSignedOrder]);
expect(ordersInfo[0].orderStatus).to.be.equal(OrderStatus.FULLY_FILLED); expect(ordersInfo[0].orderStatus).to.be.equal(OrderStatus.FullyFilled);
expect(ordersInfo[1].orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(ordersInfo[1].orderStatus).to.be.equal(OrderStatus.Fillable);
expect(ordersInfo[1].orderTakerAssetFilledAmount).to.be.bignumber.equal(new BigNumber(4)); // only 95% of ETH is sold expect(ordersInfo[1].orderTakerAssetFilledAmount).to.be.bignumber.equal(new BigNumber(4)); // only 95% of ETH is sold
}); });
it('should throw when invalid transaction and shouldValidate is true', async () => { it('should throw when invalid transaction and shouldValidate is true', async () => {

4
packages/contract-wrappers/test/order_validator_wrapper_test.ts
View File

@@ -117,9 +117,9 @@ describe('OrderValidator', () => {
it('should return correct on-chain order info for input orders', async () => { it('should return correct on-chain order info for input orders', async () => {
const firstOrderInfo = ordersInfo[0]; const firstOrderInfo = ordersInfo[0];
const secondOrderInfo = ordersInfo[1]; const secondOrderInfo = ordersInfo[1];
expect(firstOrderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(firstOrderInfo.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(firstOrderInfo.orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT); expect(firstOrderInfo.orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
expect(secondOrderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE); expect(secondOrderInfo.orderStatus).to.be.equal(OrderStatus.Fillable);
expect(secondOrderInfo.orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT); expect(secondOrderInfo.orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
}); });
it('should return correct on-chain trader info for input takers', async () => { it('should return correct on-chain trader info for input takers', async () => {

9
packages/instant/CHANGELOG.json
View File

@@ -1,4 +1,13 @@
[ [
{
"version": "2.0.0",
"changes": [
{
"note": "Renamed ActionTypes enum members to PascalCase to conform with tslint enum-naming rule",
"pr": 1474
}
]
},
{ {
"timestamp": 1542821676, "timestamp": 1542821676,
"version": "1.0.1", "version": "1.0.1",

93
packages/instant/src/redux/actions.ts
View File

@@ -21,57 +21,56 @@ function createAction<T extends string, P>(type: T, data?: P): PlainAction<T> |
} }
export enum ActionTypes { export enum ActionTypes {
SET_ACCOUNT_STATE_LOADING = 'SET_ACCOUNT_STATE_LOADING', SetAccountStateLoading = 'SET_ACCOUNT_STATE_LOADING',
SET_ACCOUNT_STATE_LOCKED = 'SET_ACCOUNT_STATE_LOCKED', SetAccountStateLocked = 'SET_ACCOUNT_STATE_LOCKED',
SET_ACCOUNT_STATE_READY = 'SET_ACCOUNT_STATE_READY', SetAccountStateReady = 'SET_ACCOUNT_STATE_READY',
UPDATE_ACCOUNT_ETH_BALANCE = 'UPDATE_ACCOUNT_ETH_BALANCE', UpdateAccountEthBalance = 'UPDATE_ACCOUNT_ETH_BALANCE',
UPDATE_ETH_USD_PRICE = 'UPDATE_ETH_USD_PRICE', UpdateEthUsdPrice = 'UPDATE_ETH_USD_PRICE',
UPDATE_SELECTED_ASSET_UNIT_AMOUNT = 'UPDATE_SELECTED_ASSET_UNIT_AMOUNT', UpdateSelectedAssetUnitAmount = 'UPDATE_SELECTED_ASSET_UNIT_AMOUNT',
SET_BUY_ORDER_STATE_NONE = 'SET_BUY_ORDER_STATE_NONE', SetBuyOrderStateNone = 'SET_BUY_ORDER_STATE_NONE',
SET_BUY_ORDER_STATE_VALIDATING = 'SET_BUY_ORDER_STATE_VALIDATING', SetBuyOrderStateValidating = 'SET_BUY_ORDER_STATE_VALIDATING',
SET_BUY_ORDER_STATE_PROCESSING = 'SET_BUY_ORDER_STATE_PROCESSING', SetBuyOrderStateProcessing = 'SET_BUY_ORDER_STATE_PROCESSING',
SET_BUY_ORDER_STATE_FAILURE = 'SET_BUY_ORDER_STATE_FAILURE', SetBuyOrderStateFailure = 'SET_BUY_ORDER_STATE_FAILURE',
SET_BUY_ORDER_STATE_SUCCESS = 'SET_BUY_ORDER_STATE_SUCCESS', SetBuyOrderStateSuccess = 'SET_BUY_ORDER_STATE_SUCCESS',
UPDATE_LATEST_BUY_QUOTE = 'UPDATE_LATEST_BUY_QUOTE', UpdateLatestBuyQuote = 'UPDATE_LATEST_BUY_QUOTE',
UPDATE_SELECTED_ASSET = 'UPDATE_SELECTED_ASSET', UpdateSelectedAsset = 'UPDATE_SELECTED_ASSET',
SET_AVAILABLE_ASSETS = 'SET_AVAILABLE_ASSETS', SetAvailableAssets = 'SET_AVAILABLE_ASSETS',
SET_QUOTE_REQUEST_STATE_PENDING = 'SET_QUOTE_REQUEST_STATE_PENDING', SetQuoteRequestStatePending = 'SET_QUOTE_REQUEST_STATE_PENDING',
SET_QUOTE_REQUEST_STATE_FAILURE = 'SET_QUOTE_REQUEST_STATE_FAILURE', SetQuoteRequestStateFailure = 'SET_QUOTE_REQUEST_STATE_FAILURE',
SET_ERROR_MESSAGE = 'SET_ERROR_MESSAGE', SetErrorMessage = 'SET_ERROR_MESSAGE',
HIDE_ERROR = 'HIDE_ERROR', HideError = 'HIDE_ERROR',
CLEAR_ERROR = 'CLEAR_ERROR', ClearError = 'CLEAR_ERROR',
RESET_AMOUNT = 'RESET_AMOUNT', ResetAmount = 'RESET_AMOUNT',
OPEN_STANDARD_SLIDING_PANEL = 'OPEN_STANDARD_SLIDING_PANEL', OpenStandardSlidingPanel = 'OPEN_STANDARD_SLIDING_PANEL',
CLOSE_STANDARD_SLIDING_PANEL = 'CLOSE_STANDARD_SLIDING_PANEL', CloseStandardSlidingPanel = 'CLOSE_STANDARD_SLIDING_PANEL',
UPDATE_BASE_CURRENCY = 'UPDATE_BASE_CURRENCY', UpdateBaseCurrency = 'UPDATE_BASE_CURRENCY',
} }
export const actions = { export const actions = {
setAccountStateLoading: () => createAction(ActionTypes.SET_ACCOUNT_STATE_LOADING), setAccountStateLoading: () => createAction(ActionTypes.SetAccountStateLoading),
setAccountStateLocked: () => createAction(ActionTypes.SET_ACCOUNT_STATE_LOCKED), setAccountStateLocked: () => createAction(ActionTypes.SetAccountStateLocked),
setAccountStateReady: (address: string) => createAction(ActionTypes.SET_ACCOUNT_STATE_READY, address), setAccountStateReady: (address: string) => createAction(ActionTypes.SetAccountStateReady, address),
updateAccountEthBalance: (addressAndBalance: AddressAndEthBalanceInWei) => updateAccountEthBalance: (addressAndBalance: AddressAndEthBalanceInWei) =>
createAction(ActionTypes.UPDATE_ACCOUNT_ETH_BALANCE, addressAndBalance), createAction(ActionTypes.UpdateAccountEthBalance, addressAndBalance),
updateEthUsdPrice: (price?: BigNumber) => createAction(ActionTypes.UPDATE_ETH_USD_PRICE, price), updateEthUsdPrice: (price?: BigNumber) => createAction(ActionTypes.UpdateEthUsdPrice, price),
updateSelectedAssetAmount: (amount?: BigNumber) => updateSelectedAssetAmount: (amount?: BigNumber) => createAction(ActionTypes.UpdateSelectedAssetUnitAmount, amount),
createAction(ActionTypes.UPDATE_SELECTED_ASSET_UNIT_AMOUNT, amount), setBuyOrderStateNone: () => createAction(ActionTypes.SetBuyOrderStateNone),
setBuyOrderStateNone: () => createAction(ActionTypes.SET_BUY_ORDER_STATE_NONE), setBuyOrderStateValidating: () => createAction(ActionTypes.SetBuyOrderStateValidating),
setBuyOrderStateValidating: () => createAction(ActionTypes.SET_BUY_ORDER_STATE_VALIDATING),
setBuyOrderStateProcessing: (txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) => setBuyOrderStateProcessing: (txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) =>
createAction(ActionTypes.SET_BUY_ORDER_STATE_PROCESSING, { txHash, startTimeUnix, expectedEndTimeUnix }), createAction(ActionTypes.SetBuyOrderStateProcessing, { txHash, startTimeUnix, expectedEndTimeUnix }),
setBuyOrderStateFailure: (txHash: string) => createAction(ActionTypes.SET_BUY_ORDER_STATE_FAILURE, txHash), setBuyOrderStateFailure: (txHash: string) => createAction(ActionTypes.SetBuyOrderStateFailure, txHash),
setBuyOrderStateSuccess: (txHash: string) => createAction(ActionTypes.SET_BUY_ORDER_STATE_SUCCESS, txHash), setBuyOrderStateSuccess: (txHash: string) => createAction(ActionTypes.SetBuyOrderStateSuccess, txHash),
updateLatestBuyQuote: (buyQuote?: BuyQuote) => createAction(ActionTypes.UPDATE_LATEST_BUY_QUOTE, buyQuote), updateLatestBuyQuote: (buyQuote?: BuyQuote) => createAction(ActionTypes.UpdateLatestBuyQuote, buyQuote),
updateSelectedAsset: (asset: Asset) => createAction(ActionTypes.UPDATE_SELECTED_ASSET, asset), updateSelectedAsset: (asset: Asset) => createAction(ActionTypes.UpdateSelectedAsset, asset),
setAvailableAssets: (availableAssets: Asset[]) => createAction(ActionTypes.SET_AVAILABLE_ASSETS, availableAssets), setAvailableAssets: (availableAssets: Asset[]) => createAction(ActionTypes.SetAvailableAssets, availableAssets),
setQuoteRequestStatePending: () => createAction(ActionTypes.SET_QUOTE_REQUEST_STATE_PENDING), setQuoteRequestStatePending: () => createAction(ActionTypes.SetQuoteRequestStatePending),
setQuoteRequestStateFailure: () => createAction(ActionTypes.SET_QUOTE_REQUEST_STATE_FAILURE), setQuoteRequestStateFailure: () => createAction(ActionTypes.SetQuoteRequestStateFailure),
setErrorMessage: (errorMessage: string) => createAction(ActionTypes.SET_ERROR_MESSAGE, errorMessage), setErrorMessage: (errorMessage: string) => createAction(ActionTypes.SetErrorMessage, errorMessage),
hideError: () => createAction(ActionTypes.HIDE_ERROR), hideError: () => createAction(ActionTypes.HideError),
clearError: () => createAction(ActionTypes.CLEAR_ERROR), clearError: () => createAction(ActionTypes.ClearError),
resetAmount: () => createAction(ActionTypes.RESET_AMOUNT), resetAmount: () => createAction(ActionTypes.ResetAmount),
openStandardSlidingPanel: (content: StandardSlidingPanelContent) => openStandardSlidingPanel: (content: StandardSlidingPanelContent) =>
createAction(ActionTypes.OPEN_STANDARD_SLIDING_PANEL, content), createAction(ActionTypes.OpenStandardSlidingPanel, content),
closeStandardSlidingPanel: () => createAction(ActionTypes.CLOSE_STANDARD_SLIDING_PANEL), closeStandardSlidingPanel: () => createAction(ActionTypes.CloseStandardSlidingPanel),
updateBaseCurrency: (baseCurrency: BaseCurrency) => createAction(ActionTypes.UPDATE_BASE_CURRENCY, baseCurrency), updateBaseCurrency: (baseCurrency: BaseCurrency) => createAction(ActionTypes.UpdateBaseCurrency, baseCurrency),
}; };

16
packages/instant/src/redux/analytics_middleware.ts
View File

@@ -21,7 +21,7 @@ export const analyticsMiddleware: Middleware = store => next => middlewareAction
const curAccount = curState.providerState.account; const curAccount = curState.providerState.account;
switch (nextAction.type) { switch (nextAction.type) {
case ActionTypes.SET_ACCOUNT_STATE_READY: case ActionTypes.SetAccountStateReady:
if (curAccount.state === AccountState.Ready) { if (curAccount.state === AccountState.Ready) {
const didJustTurnReady = prevAccount.state !== AccountState.Ready; const didJustTurnReady = prevAccount.state !== AccountState.Ready;
const didJustUpdateAddress = const didJustUpdateAddress =
@@ -38,13 +38,13 @@ export const analyticsMiddleware: Middleware = store => next => middlewareAction
} }
} }
break; break;
case ActionTypes.SET_ACCOUNT_STATE_LOCKED: case ActionTypes.SetAccountStateLocked:
if (prevAccount.state !== AccountState.Locked && curAccount.state === AccountState.Locked) { if (prevAccount.state !== AccountState.Locked && curAccount.state === AccountState.Locked) {
// if we are moving from account not locked to account locked, track `Account - Locked` // if we are moving from account not locked to account locked, track `Account - Locked`
analytics.trackAccountLocked(); analytics.trackAccountLocked();
} }
break; break;
case ActionTypes.UPDATE_ACCOUNT_ETH_BALANCE: case ActionTypes.UpdateAccountEthBalance:
if ( if (
curAccount.state === AccountState.Ready && curAccount.state === AccountState.Ready &&
curAccount.ethBalanceInWei && curAccount.ethBalanceInWei &&
@@ -58,7 +58,7 @@ export const analyticsMiddleware: Middleware = store => next => middlewareAction
analytics.addEventProperties({ ethBalanceInUnitAmount }); analytics.addEventProperties({ ethBalanceInUnitAmount });
} }
break; break;
case ActionTypes.UPDATE_SELECTED_ASSET: case ActionTypes.UpdateSelectedAsset:
const selectedAsset = curState.selectedAsset; const selectedAsset = curState.selectedAsset;
if (selectedAsset) { if (selectedAsset) {
const assetName = selectedAsset.metaData.name; const assetName = selectedAsset.metaData.name;
@@ -79,7 +79,7 @@ export const analyticsMiddleware: Middleware = store => next => middlewareAction
analytics.addEventProperties(selectedAssetEventProperties); analytics.addEventProperties(selectedAssetEventProperties);
} }
break; break;
case ActionTypes.SET_AVAILABLE_ASSETS: case ActionTypes.SetAvailableAssets:
const availableAssets = curState.availableAssets; const availableAssets = curState.availableAssets;
if (availableAssets) { if (availableAssets) {
analytics.addEventProperties({ analytics.addEventProperties({
@@ -87,19 +87,19 @@ export const analyticsMiddleware: Middleware = store => next => middlewareAction
}); });
} }
break; break;
case ActionTypes.OPEN_STANDARD_SLIDING_PANEL: case ActionTypes.OpenStandardSlidingPanel:
const openSlidingContent = curState.standardSlidingPanelSettings.content; const openSlidingContent = curState.standardSlidingPanelSettings.content;
if (openSlidingContent === StandardSlidingPanelContent.InstallWallet) { if (openSlidingContent === StandardSlidingPanelContent.InstallWallet) {
analytics.trackInstallWalletModalOpened(); analytics.trackInstallWalletModalOpened();
} }
break; break;
case ActionTypes.CLOSE_STANDARD_SLIDING_PANEL: case ActionTypes.CloseStandardSlidingPanel:
const closeSlidingContent = curState.standardSlidingPanelSettings.content; const closeSlidingContent = curState.standardSlidingPanelSettings.content;
if (closeSlidingContent === StandardSlidingPanelContent.InstallWallet) { if (closeSlidingContent === StandardSlidingPanelContent.InstallWallet) {
analytics.trackInstallWalletModalClosed(); analytics.trackInstallWalletModalClosed();
} }
break; break;
case ActionTypes.UPDATE_BASE_CURRENCY: case ActionTypes.UpdateBaseCurrency:
analytics.trackBaseCurrencyChanged(curState.baseCurrency); analytics.trackBaseCurrencyChanged(curState.baseCurrency);
analytics.addEventProperties({ baseCurrency: curState.baseCurrency }); analytics.addEventProperties({ baseCurrency: curState.baseCurrency });
} }

46
packages/instant/src/redux/reducer.ts
View File

@@ -72,11 +72,11 @@ export const DEFAULT_STATE: DefaultState = {
export const createReducer = (initialState: State) => { export const createReducer = (initialState: State) => {
const reducer = (state: State = initialState, action: Action): State => { const reducer = (state: State = initialState, action: Action): State => {
switch (action.type) { switch (action.type) {
case ActionTypes.SET_ACCOUNT_STATE_LOADING: case ActionTypes.SetAccountStateLoading:
return reduceStateWithAccount(state, LOADING_ACCOUNT); return reduceStateWithAccount(state, LOADING_ACCOUNT);
case ActionTypes.SET_ACCOUNT_STATE_LOCKED: case ActionTypes.SetAccountStateLocked:
return reduceStateWithAccount(state, LOCKED_ACCOUNT); return reduceStateWithAccount(state, LOCKED_ACCOUNT);
case ActionTypes.SET_ACCOUNT_STATE_READY: { case ActionTypes.SetAccountStateReady: {
const address = action.data; const address = action.data;
let newAccount: AccountReady = { let newAccount: AccountReady = {
state: AccountState.Ready, state: AccountState.Ready,
@@ -91,7 +91,7 @@ export const createReducer = (initialState: State) => {
} }
return reduceStateWithAccount(state, newAccount); return reduceStateWithAccount(state, newAccount);
} }
case ActionTypes.UPDATE_ACCOUNT_ETH_BALANCE: { case ActionTypes.UpdateAccountEthBalance: {
const { address, ethBalanceInWei } = action.data; const { address, ethBalanceInWei } = action.data;
const currentAccount = state.providerState.account; const currentAccount = state.providerState.account;
if (currentAccount.state !== AccountState.Ready || currentAccount.address !== address) { if (currentAccount.state !== AccountState.Ready || currentAccount.address !== address) {
@@ -104,17 +104,17 @@ export const createReducer = (initialState: State) => {
return reduceStateWithAccount(state, newAccount); return reduceStateWithAccount(state, newAccount);
} }
} }
case ActionTypes.UPDATE_ETH_USD_PRICE: case ActionTypes.UpdateEthUsdPrice:
return { return {
...state, ...state,
ethUsdPrice: action.data, ethUsdPrice: action.data,
}; };
case ActionTypes.UPDATE_SELECTED_ASSET_UNIT_AMOUNT: case ActionTypes.UpdateSelectedAssetUnitAmount:
return { return {
...state, ...state,
selectedAssetUnitAmount: action.data, selectedAssetUnitAmount: action.data,
}; };
case ActionTypes.UPDATE_LATEST_BUY_QUOTE: case ActionTypes.UpdateLatestBuyQuote:
const newBuyQuoteIfExists = action.data; const newBuyQuoteIfExists = action.data;
const shouldUpdate = const shouldUpdate =
_.isUndefined(newBuyQuoteIfExists) || doesBuyQuoteMatchState(newBuyQuoteIfExists, state); _.isUndefined(newBuyQuoteIfExists) || doesBuyQuoteMatchState(newBuyQuoteIfExists, state);
@@ -127,29 +127,29 @@ export const createReducer = (initialState: State) => {
} else { } else {
return state; return state;
} }
case ActionTypes.SET_QUOTE_REQUEST_STATE_PENDING: case ActionTypes.SetQuoteRequestStatePending:
return { return {
...state, ...state,
latestBuyQuote: undefined, latestBuyQuote: undefined,
quoteRequestState: AsyncProcessState.Pending, quoteRequestState: AsyncProcessState.Pending,
}; };
case ActionTypes.SET_QUOTE_REQUEST_STATE_FAILURE: case ActionTypes.SetQuoteRequestStateFailure:
return { return {
...state, ...state,
latestBuyQuote: undefined, latestBuyQuote: undefined,
quoteRequestState: AsyncProcessState.Failure, quoteRequestState: AsyncProcessState.Failure,
}; };
case ActionTypes.SET_BUY_ORDER_STATE_NONE: case ActionTypes.SetBuyOrderStateNone:
return { return {
...state, ...state,
buyOrderState: { processState: OrderProcessState.None }, buyOrderState: { processState: OrderProcessState.None },
}; };
case ActionTypes.SET_BUY_ORDER_STATE_VALIDATING: case ActionTypes.SetBuyOrderStateValidating:
return { return {
...state, ...state,
buyOrderState: { processState: OrderProcessState.Validating }, buyOrderState: { processState: OrderProcessState.Validating },
}; };
case ActionTypes.SET_BUY_ORDER_STATE_PROCESSING: case ActionTypes.SetBuyOrderStateProcessing:
const processingData = action.data; const processingData = action.data;
const { startTimeUnix, expectedEndTimeUnix } = processingData; const { startTimeUnix, expectedEndTimeUnix } = processingData;
return { return {
@@ -163,7 +163,7 @@ export const createReducer = (initialState: State) => {
}, },
}, },
}; };
case ActionTypes.SET_BUY_ORDER_STATE_FAILURE: case ActionTypes.SetBuyOrderStateFailure:
const failureTxHash = action.data; const failureTxHash = action.data;
if ('txHash' in state.buyOrderState) { if ('txHash' in state.buyOrderState) {
if (state.buyOrderState.txHash === failureTxHash) { if (state.buyOrderState.txHash === failureTxHash) {
@@ -179,7 +179,7 @@ export const createReducer = (initialState: State) => {
} }
} }
return state; return state;
case ActionTypes.SET_BUY_ORDER_STATE_SUCCESS: case ActionTypes.SetBuyOrderStateSuccess:
const successTxHash = action.data; const successTxHash = action.data;
if ('txHash' in state.buyOrderState) { if ('txHash' in state.buyOrderState) {
if (state.buyOrderState.txHash === successTxHash) { if (state.buyOrderState.txHash === successTxHash) {
@@ -195,29 +195,29 @@ export const createReducer = (initialState: State) => {
} }
} }
return state; return state;
case ActionTypes.SET_ERROR_MESSAGE: case ActionTypes.SetErrorMessage:
return { return {
...state, ...state,
latestErrorMessage: action.data, latestErrorMessage: action.data,
latestErrorDisplayStatus: DisplayStatus.Present, latestErrorDisplayStatus: DisplayStatus.Present,
}; };
case ActionTypes.HIDE_ERROR: case ActionTypes.HideError:
return { return {
...state, ...state,
latestErrorDisplayStatus: DisplayStatus.Hidden, latestErrorDisplayStatus: DisplayStatus.Hidden,
}; };
case ActionTypes.CLEAR_ERROR: case ActionTypes.ClearError:
return { return {
...state, ...state,
latestErrorMessage: undefined, latestErrorMessage: undefined,
latestErrorDisplayStatus: DisplayStatus.Hidden, latestErrorDisplayStatus: DisplayStatus.Hidden,
}; };
case ActionTypes.UPDATE_SELECTED_ASSET: case ActionTypes.UpdateSelectedAsset:
return { return {
...state, ...state,
selectedAsset: action.data, selectedAsset: action.data,
}; };
case ActionTypes.RESET_AMOUNT: case ActionTypes.ResetAmount:
return { return {
...state, ...state,
latestBuyQuote: undefined, latestBuyQuote: undefined,
@@ -225,12 +225,12 @@ export const createReducer = (initialState: State) => {
buyOrderState: { processState: OrderProcessState.None }, buyOrderState: { processState: OrderProcessState.None },
selectedAssetUnitAmount: undefined, selectedAssetUnitAmount: undefined,
}; };
case ActionTypes.SET_AVAILABLE_ASSETS: case ActionTypes.SetAvailableAssets:
return { return {
...state, ...state,
availableAssets: action.data, availableAssets: action.data,
}; };
case ActionTypes.OPEN_STANDARD_SLIDING_PANEL: case ActionTypes.OpenStandardSlidingPanel:
return { return {
...state, ...state,
standardSlidingPanelSettings: { standardSlidingPanelSettings: {
@@ -238,7 +238,7 @@ export const createReducer = (initialState: State) => {
animationState: 'slidIn', animationState: 'slidIn',
}, },
}; };
case ActionTypes.CLOSE_STANDARD_SLIDING_PANEL: case ActionTypes.CloseStandardSlidingPanel:
return { return {
...state, ...state,
standardSlidingPanelSettings: { standardSlidingPanelSettings: {
@@ -246,7 +246,7 @@ export const createReducer = (initialState: State) => {
animationState: 'slidOut', animationState: 'slidOut',
}, },
}; };
case ActionTypes.UPDATE_BASE_CURRENCY: case ActionTypes.UpdateBaseCurrency:
return { return {
...state, ...state,
baseCurrency: action.data, baseCurrency: action.data,

2
packages/instant/src/style/theme.ts
View File

@@ -11,7 +11,7 @@ const {
} = styledComponents; } = styledComponents;
export type Theme = { [key in ColorOption]: string }; export type Theme = { [key in ColorOption]: string };
// tslint:disable:enum-naming
export enum ColorOption { export enum ColorOption {
primaryColor = 'primaryColor', primaryColor = 'primaryColor',
black = 'black', black = 'black',

8
packages/instant/src/types.ts
View File

@@ -27,8 +27,8 @@ export enum QuoteFetchOrigin {
} }
export enum BaseCurrency { export enum BaseCurrency {
USD = 'USD', USD = 'USD', // tslint:disable-line:enum-naming
ETH = 'ETH', ETH = 'ETH', // tslint:disable-line:enum-naming
} }
export interface SimulatedProgress { export interface SimulatedProgress {
@@ -95,7 +95,7 @@ export enum Network {
export enum ZeroExInstantError { export enum ZeroExInstantError {
AssetMetaDataNotAvailable = 'ASSET_META_DATA_NOT_AVAILABLE', AssetMetaDataNotAvailable = 'ASSET_META_DATA_NOT_AVAILABLE',
InsufficientETH = 'INSUFFICIENT_ETH', InsufficientETH = 'INSUFFICIENT_ETH', // tslint:disable-line:enum-naming
CouldNotSubmitTransaction = 'COULD_NOT_SUBMIT_TRANSACTION', CouldNotSubmitTransaction = 'COULD_NOT_SUBMIT_TRANSACTION',
} }
@@ -168,7 +168,7 @@ export enum WalletSuggestion {
export enum OperatingSystem { export enum OperatingSystem {
Android = 'ANDROID', Android = 'ANDROID',
iOS = 'IOS', iOS = 'IOS', // tslint:disable-line:enum-naming
Mac = 'MAC', Mac = 'MAC',
Windows = 'WINDOWS', Windows = 'WINDOWS',
WindowsPhone = 'WINDOWS_PHONE', WindowsPhone = 'WINDOWS_PHONE',

130
packages/instant/src/util/analytics.ts
View File

@@ -31,38 +31,38 @@ export const evaluateIfEnabled = (fnCall: () => void) => {
}; };
enum EventNames { enum EventNames {
INSTANT_OPENED = 'Instant - Opened', InstantOpened = 'Instant - Opened',
INSTANT_CLOSED = 'Instant - Closed', InstantClosed = 'Instant - Closed',
ACCOUNT_LOCKED = 'Account - Locked', AccountLocked = 'Account - Locked',
ACCOUNT_READY = 'Account - Ready', AccountReady = 'Account - Ready',
ACCOUNT_UNLOCK_REQUESTED = 'Account - Unlock Requested', AccountUnlockRequested = 'Account - Unlock Requested',
ACCOUNT_UNLOCK_DENIED = 'Account - Unlock Denied', AccountUnlockDenied = 'Account - Unlock Denied',
ACCOUNT_ADDRESS_CHANGED = 'Account - Address Changed', AccountAddressChanged = 'Account - Address Changed',
BASE_CURRENCY_CHANGED = 'Base Currency - Changed', BaseCurrencyChanged = 'Base Currency - Changed',
PAYMENT_METHOD_DROPDOWN_OPENED = 'Payment Method - Dropdown Opened', PaymentMethodDropdownOpened = 'Payment Method - Dropdown Opened',
PAYMENT_METHOD_OPENED_ETHERSCAN = 'Payment Method - Opened Etherscan', PaymentMethodOpenedEtherscan = 'Payment Method - Opened Etherscan',
PAYMENT_METHOD_COPIED_ADDRESS = 'Payment Method - Copied Address', PaymentMethodCopiedAddress = 'Payment Method - Copied Address',
BUY_NOT_ENOUGH_ETH = 'Buy - Not Enough Eth', BuyNotEnoughEth = 'Buy - Not Enough Eth',
BUY_STARTED = 'Buy - Started', BuyStarted = 'Buy - Started',
BUY_SIGNATURE_DENIED = 'Buy - Signature Denied', BuySignatureDenied = 'Buy - Signature Denied',
BUY_SIMULATION_FAILED = 'Buy - Simulation Failed', BuySimulationFailed = 'Buy - Simulation Failed',
BUY_UNKNOWN_ERROR = 'Buy - Unknown Error', BuyUnknownError = 'Buy - Unknown Error',
BUY_TX_SUBMITTED = 'Buy - Tx Submitted', BuyTxSubmitted = 'Buy - Tx Submitted',
BUY_TX_SUCCEEDED = 'Buy - Tx Succeeded', BuyTxSucceeded = 'Buy - Tx Succeeded',
BUY_TX_FAILED = 'Buy - Tx Failed', BuyTxFailed = 'Buy - Tx Failed',
USD_PRICE_FETCH_FAILED = 'USD Price - Fetch Failed', UsdPriceFetchFailed = 'USD Price - Fetch Failed',
INSTALL_WALLET_CLICKED = 'Install Wallet - Clicked', InstallWalletClicked = 'Install Wallet - Clicked',
INSTALL_WALLET_MODAL_OPENED = 'Install Wallet - Modal - Opened', InstallWalletModalOpened = 'Install Wallet - Modal - Opened',
INSTALL_WALLET_MODAL_CLICKED_EXPLANATION = 'Install Wallet - Modal - Clicked Explanation', InstallWalletModalClickedExplanation = 'Install Wallet - Modal - Clicked Explanation',
INSTALL_WALLET_MODAL_CLICKED_GET = 'Install Wallet - Modal - Clicked Get', InstallWalletModalClickedGet = 'Install Wallet - Modal - Clicked Get',
INSTALL_WALLET_MODAL_CLOSED = 'Install Wallet - Modal - Closed', InstallWalletModalClosed = 'Install Wallet - Modal - Closed',
TOKEN_SELECTOR_OPENED = 'Token Selector - Opened', TokenSelectorOpened = 'Token Selector - Opened',
TOKEN_SELECTOR_CLOSED = 'Token Selector - Closed', TokenSelectorClosed = 'Token Selector - Closed',
TOKEN_SELECTOR_CHOSE = 'Token Selector - Chose', TokenSelectorChose = 'Token Selector - Chose',
TOKEN_SELECTOR_SEARCHED = 'Token Selector - Searched', TokenSelectorSearched = 'Token Selector - Searched',
TRANSACTION_VIEWED = 'Transaction - Viewed', TransactionViewed = 'Transaction - Viewed',
QUOTE_FETCHED = 'Quote - Fetched', QuoteFetched = 'Quote - Fetched',
QUOTE_ERROR = 'Quote - Error', QuoteError = 'Quote - Error',
} }
const track = (eventName: EventNames, eventProperties: EventProperties = {}): void => { const track = (eventName: EventNames, eventProperties: EventProperties = {}): void => {
@@ -125,7 +125,7 @@ export interface AnalyticsEventOptions {
baseCurrency?: string; baseCurrency?: string;
} }
export enum TokenSelectorClosedVia { export enum TokenSelectorClosedVia {
ClickedX = 'Clicked X', ClickedX = 'Clicked X', // tslint:disable-line:enum-naming
TokenChose = 'Token Chose', TokenChose = 'Token Chose',
} }
export const analytics = { export const analytics = {
@@ -169,80 +169,80 @@ export const analytics = {
}; };
return eventOptions; return eventOptions;
}, },
trackInstantOpened: trackingEventFnWithoutPayload(EventNames.INSTANT_OPENED), trackInstantOpened: trackingEventFnWithoutPayload(EventNames.InstantOpened),
trackInstantClosed: trackingEventFnWithoutPayload(EventNames.INSTANT_CLOSED), trackInstantClosed: trackingEventFnWithoutPayload(EventNames.InstantClosed),
trackAccountLocked: trackingEventFnWithoutPayload(EventNames.ACCOUNT_LOCKED), trackAccountLocked: trackingEventFnWithoutPayload(EventNames.AccountLocked),
trackAccountReady: (address: string) => trackingEventFnWithPayload(EventNames.ACCOUNT_READY)({ address }), trackAccountReady: (address: string) => trackingEventFnWithPayload(EventNames.AccountReady)({ address }),
trackAccountUnlockRequested: trackingEventFnWithoutPayload(EventNames.ACCOUNT_UNLOCK_REQUESTED), trackAccountUnlockRequested: trackingEventFnWithoutPayload(EventNames.AccountUnlockRequested),
trackAccountUnlockDenied: trackingEventFnWithoutPayload(EventNames.ACCOUNT_UNLOCK_DENIED), trackAccountUnlockDenied: trackingEventFnWithoutPayload(EventNames.AccountUnlockDenied),
trackAccountAddressChanged: (address: string) => trackAccountAddressChanged: (address: string) =>
trackingEventFnWithPayload(EventNames.ACCOUNT_ADDRESS_CHANGED)({ address }), trackingEventFnWithPayload(EventNames.AccountAddressChanged)({ address }),
trackBaseCurrencyChanged: (currencyChangedTo: BaseCurrency) => trackBaseCurrencyChanged: (currencyChangedTo: BaseCurrency) =>
trackingEventFnWithPayload(EventNames.BASE_CURRENCY_CHANGED)({ currencyChangedTo }), trackingEventFnWithPayload(EventNames.BaseCurrencyChanged)({ currencyChangedTo }),
trackPaymentMethodDropdownOpened: trackingEventFnWithoutPayload(EventNames.PAYMENT_METHOD_DROPDOWN_OPENED), trackPaymentMethodDropdownOpened: trackingEventFnWithoutPayload(EventNames.PaymentMethodDropdownOpened),
trackPaymentMethodOpenedEtherscan: trackingEventFnWithoutPayload(EventNames.PAYMENT_METHOD_OPENED_ETHERSCAN), trackPaymentMethodOpenedEtherscan: trackingEventFnWithoutPayload(EventNames.PaymentMethodOpenedEtherscan),
trackPaymentMethodCopiedAddress: trackingEventFnWithoutPayload(EventNames.PAYMENT_METHOD_COPIED_ADDRESS), trackPaymentMethodCopiedAddress: trackingEventFnWithoutPayload(EventNames.PaymentMethodCopiedAddress),
trackBuyNotEnoughEth: (buyQuote: BuyQuote) => trackBuyNotEnoughEth: (buyQuote: BuyQuote) =>
trackingEventFnWithPayload(EventNames.BUY_NOT_ENOUGH_ETH)(buyQuoteEventProperties(buyQuote)), trackingEventFnWithPayload(EventNames.BuyNotEnoughEth)(buyQuoteEventProperties(buyQuote)),
trackBuyStarted: (buyQuote: BuyQuote) => trackBuyStarted: (buyQuote: BuyQuote) =>
trackingEventFnWithPayload(EventNames.BUY_STARTED)(buyQuoteEventProperties(buyQuote)), trackingEventFnWithPayload(EventNames.BuyStarted)(buyQuoteEventProperties(buyQuote)),
trackBuySignatureDenied: (buyQuote: BuyQuote) => trackBuySignatureDenied: (buyQuote: BuyQuote) =>
trackingEventFnWithPayload(EventNames.BUY_SIGNATURE_DENIED)(buyQuoteEventProperties(buyQuote)), trackingEventFnWithPayload(EventNames.BuySignatureDenied)(buyQuoteEventProperties(buyQuote)),
trackBuySimulationFailed: (buyQuote: BuyQuote) => trackBuySimulationFailed: (buyQuote: BuyQuote) =>
trackingEventFnWithPayload(EventNames.BUY_SIMULATION_FAILED)(buyQuoteEventProperties(buyQuote)), trackingEventFnWithPayload(EventNames.BuySimulationFailed)(buyQuoteEventProperties(buyQuote)),
trackBuyUnknownError: (buyQuote: BuyQuote, errorMessage: string) => trackBuyUnknownError: (buyQuote: BuyQuote, errorMessage: string) =>
trackingEventFnWithPayload(EventNames.BUY_UNKNOWN_ERROR)({ trackingEventFnWithPayload(EventNames.BuyUnknownError)({
...buyQuoteEventProperties(buyQuote), ...buyQuoteEventProperties(buyQuote),
errorMessage, errorMessage,
}), }),
trackBuyTxSubmitted: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) => trackBuyTxSubmitted: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) =>
trackingEventFnWithPayload(EventNames.BUY_TX_SUBMITTED)({ trackingEventFnWithPayload(EventNames.BuyTxSubmitted)({
...buyQuoteEventProperties(buyQuote), ...buyQuoteEventProperties(buyQuote),
txHash, txHash,
expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix, expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix,
}), }),
trackBuyTxSucceeded: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) => trackBuyTxSucceeded: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) =>
trackingEventFnWithPayload(EventNames.BUY_TX_SUCCEEDED)({ trackingEventFnWithPayload(EventNames.BuyTxSucceeded)({
...buyQuoteEventProperties(buyQuote), ...buyQuoteEventProperties(buyQuote),
txHash, txHash,
expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix, expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix,
actualTxTimeMs: new Date().getTime() - startTimeUnix, actualTxTimeMs: new Date().getTime() - startTimeUnix,
}), }),
trackBuyTxFailed: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) => trackBuyTxFailed: (buyQuote: BuyQuote, txHash: string, startTimeUnix: number, expectedEndTimeUnix: number) =>
trackingEventFnWithPayload(EventNames.BUY_TX_FAILED)({ trackingEventFnWithPayload(EventNames.BuyTxFailed)({
...buyQuoteEventProperties(buyQuote), ...buyQuoteEventProperties(buyQuote),
txHash, txHash,
expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix, expectedTxTimeMs: expectedEndTimeUnix - startTimeUnix,
actualTxTimeMs: new Date().getTime() - startTimeUnix, actualTxTimeMs: new Date().getTime() - startTimeUnix,
}), }),
trackInstallWalletClicked: (walletSuggestion: WalletSuggestion) => trackInstallWalletClicked: (walletSuggestion: WalletSuggestion) =>
trackingEventFnWithPayload(EventNames.INSTALL_WALLET_CLICKED)({ walletSuggestion }), trackingEventFnWithPayload(EventNames.InstallWalletClicked)({ walletSuggestion }),
trackInstallWalletModalClickedExplanation: trackingEventFnWithoutPayload( trackInstallWalletModalClickedExplanation: trackingEventFnWithoutPayload(
EventNames.INSTALL_WALLET_MODAL_CLICKED_EXPLANATION, EventNames.InstallWalletModalClickedExplanation,
), ),
trackInstallWalletModalClickedGet: trackingEventFnWithoutPayload(EventNames.INSTALL_WALLET_MODAL_CLICKED_GET), trackInstallWalletModalClickedGet: trackingEventFnWithoutPayload(EventNames.InstallWalletModalClickedGet),
trackInstallWalletModalOpened: trackingEventFnWithoutPayload(EventNames.INSTALL_WALLET_MODAL_OPENED), trackInstallWalletModalOpened: trackingEventFnWithoutPayload(EventNames.InstallWalletModalOpened),
trackInstallWalletModalClosed: trackingEventFnWithoutPayload(EventNames.INSTALL_WALLET_MODAL_CLOSED), trackInstallWalletModalClosed: trackingEventFnWithoutPayload(EventNames.InstallWalletModalClosed),
trackTokenSelectorOpened: trackingEventFnWithoutPayload(EventNames.TOKEN_SELECTOR_OPENED), trackTokenSelectorOpened: trackingEventFnWithoutPayload(EventNames.TokenSelectorOpened),
trackTokenSelectorClosed: (closedVia: TokenSelectorClosedVia) => trackTokenSelectorClosed: (closedVia: TokenSelectorClosedVia) =>
trackingEventFnWithPayload(EventNames.TOKEN_SELECTOR_CLOSED)({ closedVia }), trackingEventFnWithPayload(EventNames.TokenSelectorClosed)({ closedVia }),
trackTokenSelectorChose: (payload: { assetName: string; assetData: string }) => trackTokenSelectorChose: (payload: { assetName: string; assetData: string }) =>
trackingEventFnWithPayload(EventNames.TOKEN_SELECTOR_CHOSE)(payload), trackingEventFnWithPayload(EventNames.TokenSelectorChose)(payload),
trackTokenSelectorSearched: (searchText: string) => trackTokenSelectorSearched: (searchText: string) =>
trackingEventFnWithPayload(EventNames.TOKEN_SELECTOR_SEARCHED)({ searchText }), trackingEventFnWithPayload(EventNames.TokenSelectorSearched)({ searchText }),
trackTransactionViewed: (orderProcesState: OrderProcessState) => trackTransactionViewed: (orderProcesState: OrderProcessState) =>
trackingEventFnWithPayload(EventNames.TRANSACTION_VIEWED)({ orderState: orderProcesState }), trackingEventFnWithPayload(EventNames.TransactionViewed)({ orderState: orderProcesState }),
trackQuoteFetched: (buyQuote: BuyQuote, fetchOrigin: QuoteFetchOrigin) => trackQuoteFetched: (buyQuote: BuyQuote, fetchOrigin: QuoteFetchOrigin) =>
trackingEventFnWithPayload(EventNames.QUOTE_FETCHED)({ trackingEventFnWithPayload(EventNames.QuoteFetched)({
...buyQuoteEventProperties(buyQuote), ...buyQuoteEventProperties(buyQuote),
fetchOrigin, fetchOrigin,
}), }),
trackQuoteError: (errorMessage: string, assetBuyAmount: BigNumber, fetchOrigin: QuoteFetchOrigin) => { trackQuoteError: (errorMessage: string, assetBuyAmount: BigNumber, fetchOrigin: QuoteFetchOrigin) => {
trackingEventFnWithPayload(EventNames.QUOTE_ERROR)({ trackingEventFnWithPayload(EventNames.QuoteError)({
errorMessage, errorMessage,
assetBuyAmount: assetBuyAmount.toString(), assetBuyAmount: assetBuyAmount.toString(),
fetchOrigin, fetchOrigin,
}); });
}, },
trackUsdPriceFailed: trackingEventFnWithoutPayload(EventNames.USD_PRICE_FETCH_FAILED), trackUsdPriceFailed: trackingEventFnWithoutPayload(EventNames.UsdPriceFetchFailed),
}; };

6
packages/pipeline/src/parsers/copper/index.ts
View File

@@ -44,8 +44,8 @@ export interface CopperActivityParentResponse {
// custom activity types // custom activity types
export enum CopperActivityTypeCategory { export enum CopperActivityTypeCategory {
user = 'user', User = 'user',
system = 'system', System = 'system',
} }
export interface CopperActivityTypeResponse { export interface CopperActivityTypeResponse {
id: number; id: number;
@@ -90,7 +90,7 @@ export enum CopperCustomFieldType {
Date = 'Date', Date = 'Date',
Checkbox = 'Checkbox', Checkbox = 'Checkbox',
Float = 'Float', Float = 'Float',
URL = 'URL', URL = 'URL', // tslint:disable-line:enum-naming
Percentage = 'Percentage', Percentage = 'Percentage',
Currency = 'Currency', Currency = 'Currency',
Connect = 'Connect', Connect = 'Connect',

6
packages/testnet-faucets/src/ts/handler.ts
View File

@@ -36,9 +36,9 @@ interface ItemByNetworkId<T> {
} }
enum RequestedAssetType { enum RequestedAssetType {
ETH = 'ETH', ETH = 'ETH', // tslint:disable-line:enum-naming
WETH = 'WETH', WETH = 'WETH', // tslint:disable-line:enum-naming
ZRX = 'ZRX', ZRX = 'ZRX', // tslint:disable-line:enum-naming
} }
const FIVE_DAYS_IN_MS = 4.32e8; // TODO: make this configurable const FIVE_DAYS_IN_MS = 4.32e8; // TODO: make this configurable

1
packages/tslint-config/package.json
View File

@@ -9,6 +9,7 @@
"scripts": { "scripts": {
"build": "tsc -b", "build": "tsc -b",
"build:ci": "yarn build", "build:ci": "yarn build",
"test": "mocha ./lib/test/*.spec.js",
"clean": "shx rm -rf lib", "clean": "shx rm -rf lib",
"lint": "tslint --format stylish --project ." "lint": "tslint --format stylish --project ."
}, },

60
packages/tslint-config/rules/enumNamingRule.ts Normal file
View File

@@ -0,0 +1,60 @@
import * as Lint from 'tslint';
import * as ts from 'typescript';
export class Rule extends Lint.Rules.AbstractRule {
public static FAILURE_STRING = `Enum member names should be PascalCase`;
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithFunction(sourceFile, walk);
}
}
function walk(ctx: Lint.WalkContext<void>): void {
// Recursively walk the AST starting with root node, `ctx.sourceFile`.
// Call the function `cb` (defined below) for each child.
return ts.forEachChild(ctx.sourceFile, cb);
function cb(node: ts.Node): void {
if (node.kind === ts.SyntaxKind.EnumMember) {
const keyNode = node.getFirstToken(ctx.sourceFile);
if (keyNode !== undefined) {
const keyText = keyNode.getText(ctx.sourceFile);
if (!isPascalCase(keyText)) {
return ctx.addFailureAtNode(node, Rule.FAILURE_STRING, getFix(keyText, node));
}
}
}
// Continue recursion into the AST by calling function `cb` for every child of the current node.
return ts.forEachChild(node, cb);
}
function getFix(text: string, node: ts.Node): Lint.Replacement {
let fix = toPascalCase(text);
// check for `member = value`
if (node.getChildCount(ctx.sourceFile) === 3) {
const value = node.getLastToken(ctx.sourceFile);
if (value !== undefined) {
fix += ` = ${value.getText(ctx.sourceFile)}`;
}
}
return new Lint.Replacement(node.getStart(ctx.sourceFile), node.getWidth(ctx.sourceFile), fix);
}
}
// Modified from: https://github.com/jonschlinkert/pascalcase/
function toPascalCase(str: string): string {
let result = str.replace(/([a-z0-9\W])([A-Z])/g, '$1 $2');
if (result.length === 1) {
return result.toUpperCase();
}
result = result.replace(/^[\W_\.]+|[\W_\.]+$/g, '').toLowerCase();
result = result.charAt(0).toUpperCase() + result.slice(1);
return result.replace(/[\W_\.]+(\w|$)/g, (_, ch) => {
return ch.toUpperCase();
});
}
function isPascalCase(s: string): boolean {
const regex = /^([A-Z0-9]+[a-z0-9]+)+$/g;
const key = s.split('=')[0].trim();
return regex.test(key);
}

88
packages/tslint-config/test/enumNamingSpec.spec.ts Normal file
View File

@@ -0,0 +1,88 @@
import * as assert from 'assert';
import { Rule } from '../rules/enumNamingRule';
import { getFixedResult, helper } from './lintrunner';
const rule = 'enum-naming';
describe('enumNamingRule', () => {
it(`should not fail PascalCase`, () => {
const src = `enum test { MemberOne, MemberTwo }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 0);
});
it(`should not fail PascalCase keys with uncased values`, () => {
const src = `enum test { MemberOne = 'member_one', MemberTwo = 'member two' }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 0);
});
it(`should not fail PascalCase keys with numbers`, () => {
const src = `enum test { Member1 = 'member_one', MemberTwo = 'member two' }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 0);
});
it(`should fail with camelCase`, () => {
const src = `enum test { memberOne, memberTwo }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 2);
});
it(`should fail with snake case`, () => {
const src = `enum test { member_one, member_two }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 2);
});
it(`should fail with all caps`, () => {
const src = `enum test { MEMBERONE, MEMBER_TWO }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 2);
});
it(`should fail with mixed case`, () => {
const src = `enum test { member_one, MemberTwo }`;
const result = helper(src, rule);
assert.equal(result.errorCount, 1);
});
it(`should fail with the right position`, () => {
const src = `enum test { MemberOne, member_two }`;
const startPosition = src.indexOf('member_two');
const endPosition = startPosition + 'member_two'.length;
const failure = helper(src, rule).failures[0];
assert.equal(failure.getStartPosition().getPosition(), startPosition);
assert.equal(failure.getEndPosition().getPosition(), endPosition);
assert.equal(failure.getFailure(), Rule.FAILURE_STRING);
});
it(`should fail with the right message`, () => {
const src = `enum test { memberOne, memberTwo }`;
const failure = helper(src, rule).failures[0];
assert.equal(failure.getFailure(), Rule.FAILURE_STRING);
});
});
describe('enumNaming fixer', () => {
it('should fix keys', () => {
const src = `enum test { MemberOne, memberTwo, member_three, MEMBER_FOUR, MEMBERFIVE }`;
const expected = `enum test { MemberOne, MemberTwo, MemberThree, MemberFour, Memberfive }`;
const actual = getFixedResult(src, rule);
const result = helper(src, rule);
assert.equal(result.errorCount, 4); // tslint:disable-line:custom-no-magic-numbers
assert.equal(actual, expected);
});
it('should not fix values', () => {
const src = `enum test { MemberOne = 'MemberOne', memberTwo = 'memberTwo', member_three = 'member_three', MEMBER_FOUR = 'MEMBER_FOUR' }`;
const expected = `enum test { MemberOne = 'MemberOne', MemberTwo = 'memberTwo', MemberThree = 'member_three', MemberFour = 'MEMBER_FOUR' }`;
const actual = getFixedResult(src, rule);
const result = helper(src, rule);
assert.equal(result.errorCount, 3); // tslint:disable-line:custom-no-magic-numbers
assert.equal(actual, expected);
});
it('should preserve values with equals sign', () => {
const src = `enum Operators { assign = '=', EQUALS = '==', Triple_Equals = '===' }`;
const expected = `enum Operators { Assign = '=', Equals = '==', TripleEquals = '===' }`;
const actual = getFixedResult(src, rule);
const result = helper(src, rule);
assert.equal(result.errorCount, 3); // tslint:disable-line:custom-no-magic-numbers
assert.equal(actual, expected);
});
});

23
packages/tslint-config/test/lintrunner.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as path from 'path';
import { Configuration, Linter, Replacement } from 'tslint';
export const helper = (src: string, rule: string) => {
const linter = new Linter({ fix: false });
linter.lint(
'',
src,
Configuration.parseConfigFile({
rules: {
[rule]: true,
},
rulesDirectory: path.join(__dirname, '../rules'),
}),
);
return linter.getResult();
};
export const getFixedResult = (src: string, rule: string) => {
const result = helper(src, rule);
const fixes = [].concat.apply(result.failures.map(x => x.getFix()));
return Replacement.applyFixes(src, fixes);
};

4
packages/tslint-config/tsconfig.json
View File

@@ -2,7 +2,7 @@
"extends": "../../tsconfig", "extends": "../../tsconfig",
"compilerOptions": { "compilerOptions": {
"outDir": "lib", "outDir": "lib",
"rootDir": "rules" "rootDir": "."
}, },
"include": ["./rules/**/*"] "include": ["./rules/**/*", "test/**/*"]
} }

3
packages/tslint-config/tslint.json
View File

@@ -25,6 +25,7 @@
"curly": true, "curly": true,
"custom-no-magic-numbers": [true, 0, 1, 2, 3, -1], "custom-no-magic-numbers": [true, 0, 1, 2, 3, -1],
"encoding": true, "encoding": true,
"enum-naming": true,
"eofline": true, "eofline": true,
"import-spacing": true, "import-spacing": true,
"indent": [true, "spaces", 4], "indent": [true, "spaces", 4],
@@ -125,5 +126,5 @@
"check-preblock" "check-preblock"
] ]
}, },
"rulesDirectory": "lib" "rulesDirectory": "lib/rules"
} }

18
packages/website/ts/components/dialogs/ledger_config_dialog.tsx
View File

@@ -20,8 +20,8 @@ import { utils } from 'ts/utils/utils';
const VALID_ETHEREUM_DERIVATION_PATH_PREFIX = `44'/60'`; const VALID_ETHEREUM_DERIVATION_PATH_PREFIX = `44'/60'`;
enum LedgerSteps { enum LedgerSteps {
CONNECT, Connect,
SELECT_ADDRESS, SelectAddress,
} }
interface LedgerConfigDialogProps { interface LedgerConfigDialogProps {
@@ -52,7 +52,7 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
const derivationPathIfExists = props.blockchain.getLedgerDerivationPathIfExists(); const derivationPathIfExists = props.blockchain.getLedgerDerivationPathIfExists();
this.state = { this.state = {
connectionErrMsg: '', connectionErrMsg: '',
stepIndex: LedgerSteps.CONNECT, stepIndex: LedgerSteps.Connect,
userAddresses: [], userAddresses: [],
addressBalances: [], addressBalances: [],
derivationPath: _.isUndefined(derivationPathIfExists) derivationPath: _.isUndefined(derivationPathIfExists)
@@ -67,7 +67,7 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
<FlatButton key="ledgerConnectCancel" label="Cancel" onClick={this._onClose.bind(this)} />, <FlatButton key="ledgerConnectCancel" label="Cancel" onClick={this._onClose.bind(this)} />,
]; ];
const dialogTitle = const dialogTitle =
this.state.stepIndex === LedgerSteps.CONNECT ? 'Connect to your Ledger' : 'Select desired address'; this.state.stepIndex === LedgerSteps.Connect ? 'Connect to your Ledger' : 'Select desired address';
return ( return (
<Dialog <Dialog
title={dialogTitle} title={dialogTitle}
@@ -79,8 +79,8 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
bodyStyle={{ paddingBottom: 0 }} bodyStyle={{ paddingBottom: 0 }}
> >
<div style={{ color: colors.grey700, paddingTop: 1 }}> <div style={{ color: colors.grey700, paddingTop: 1 }}>
{this.state.stepIndex === LedgerSteps.CONNECT && this._renderConnectStep()} {this.state.stepIndex === LedgerSteps.Connect && this._renderConnectStep()}
{this.state.stepIndex === LedgerSteps.SELECT_ADDRESS && this._renderSelectAddressStep()} {this.state.stepIndex === LedgerSteps.SelectAddress && this._renderSelectAddressStep()}
</div> </div>
</Dialog> </Dialog>
); );
@@ -195,7 +195,7 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
private _onClose(): void { private _onClose(): void {
this.setState({ this.setState({
connectionErrMsg: '', connectionErrMsg: '',
stepIndex: LedgerSteps.CONNECT, stepIndex: LedgerSteps.Connect,
}); });
const isOpen = false; const isOpen = false;
this.props.toggleDialogFn(isOpen); this.props.toggleDialogFn(isOpen);
@@ -210,7 +210,7 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
this.props.blockchain.fetchTokenInformationAsync(); this.props.blockchain.fetchTokenInformationAsync();
this.props.dispatcher.updateUserWeiBalance(selectAddressBalance); this.props.dispatcher.updateUserWeiBalance(selectAddressBalance);
this.setState({ this.setState({
stepIndex: LedgerSteps.CONNECT, stepIndex: LedgerSteps.Connect,
}); });
const isOpen = false; const isOpen = false;
this.props.toggleDialogFn(isOpen); this.props.toggleDialogFn(isOpen);
@@ -284,7 +284,7 @@ export class LedgerConfigDialog extends React.Component<LedgerConfigDialogProps,
const didSucceed = await this._fetchAddressesAndBalancesAsync(); const didSucceed = await this._fetchAddressesAndBalancesAsync();
if (didSucceed) { if (didSucceed) {
this.setState({ this.setState({
stepIndex: LedgerSteps.SELECT_ADDRESS, stepIndex: LedgerSteps.SelectAddress,
connectionErrMsg: '', connectionErrMsg: '',
}); });
} }

8
packages/website/ts/components/fill_order.tsx
View File

@@ -182,7 +182,7 @@ export class FillOrder extends React.Component<FillOrderProps, FillOrderState> {
</div> </div>
)} )}
{!_.isEmpty(this.state.orderJSONErrMsg) && ( {!_.isEmpty(this.state.orderJSONErrMsg) && (
<Alert type={AlertTypes.ERROR} message={this.state.orderJSONErrMsg} /> <Alert type={AlertTypes.Error} message={this.state.orderJSONErrMsg} />
)} )}
</div> </div>
); );
@@ -298,7 +298,7 @@ export class FillOrder extends React.Component<FillOrderProps, FillOrderState> {
onClick={this._onCancelOrderClickFireAndForgetAsync.bind(this)} onClick={this._onCancelOrderClickFireAndForgetAsync.bind(this)}
/> />
{this.state.didCancelOrderSucceed && ( {this.state.didCancelOrderSucceed && (
<Alert type={AlertTypes.SUCCESS} message={this._renderCancelSuccessMsg()} /> <Alert type={AlertTypes.Success} message={this._renderCancelSuccessMsg()} />
)} )}
</div> </div>
) : ( ) : (
@@ -310,10 +310,10 @@ export class FillOrder extends React.Component<FillOrderProps, FillOrderState> {
onClick={this._onFillOrderClick.bind(this)} onClick={this._onFillOrderClick.bind(this)}
/> />
{!_.isEmpty(this.state.globalErrMsg) && ( {!_.isEmpty(this.state.globalErrMsg) && (
<Alert type={AlertTypes.ERROR} message={this.state.globalErrMsg} /> <Alert type={AlertTypes.Error} message={this.state.globalErrMsg} />
)} )}
{this.state.didFillOrderSucceed && ( {this.state.didFillOrderSucceed && (
<Alert type={AlertTypes.SUCCESS} message={this._renderFillSuccessMsg()} /> <Alert type={AlertTypes.Success} message={this._renderFillSuccessMsg()} />
)} )}
</div> </div>
)} )}

42
packages/website/ts/components/generate_order/asset_picker.tsx
View File

@@ -18,9 +18,9 @@ import { utils } from 'ts/utils/utils';
const TOKEN_ICON_DIMENSION = 100; const TOKEN_ICON_DIMENSION = 100;
const TILE_DIMENSION = 146; const TILE_DIMENSION = 146;
enum AssetViews { enum AssetViews {
ASSET_PICKER = 'ASSET_PICKER', AssetPicker = 'ASSET_PICKER',
NEW_TOKEN_FORM = 'NEW_TOKEN_FORM', NewTokenForm = 'NEW_TOKEN_FORM',
CONFIRM_TRACK_TOKEN = 'CONFIRM_TRACK_TOKEN', ConfirmTrackToken = 'CONFIRM_TRACK_TOKEN',
} }
interface AssetPickerProps { interface AssetPickerProps {
@@ -44,29 +44,29 @@ interface AssetPickerState {
export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerState> { export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerState> {
public static defaultProps: Partial<AssetPickerProps> = { public static defaultProps: Partial<AssetPickerProps> = {
tokenVisibility: TokenVisibility.ALL, tokenVisibility: TokenVisibility.All,
}; };
private readonly _dialogConfigsByAssetView: { [assetView: string]: DialogConfigs }; private readonly _dialogConfigsByAssetView: { [assetView: string]: DialogConfigs };
constructor(props: AssetPickerProps) { constructor(props: AssetPickerProps) {
super(props); super(props);
this.state = { this.state = {
assetView: AssetViews.ASSET_PICKER, assetView: AssetViews.AssetPicker,
hoveredAddress: undefined, hoveredAddress: undefined,
chosenTrackTokenAddress: undefined, chosenTrackTokenAddress: undefined,
isAddingTokenToTracked: false, isAddingTokenToTracked: false,
}; };
this._dialogConfigsByAssetView = { this._dialogConfigsByAssetView = {
[AssetViews.ASSET_PICKER]: { [AssetViews.AssetPicker]: {
title: 'Select token', title: 'Select token',
isModal: false, isModal: false,
actions: [], actions: [],
}, },
[AssetViews.NEW_TOKEN_FORM]: { [AssetViews.NewTokenForm]: {
title: 'Add an ERC20 token', title: 'Add an ERC20 token',
isModal: false, isModal: false,
actions: [], actions: [],
}, },
[AssetViews.CONFIRM_TRACK_TOKEN]: { [AssetViews.ConfirmTrackToken]: {
title: 'Tracking confirmation', title: 'Tracking confirmation',
isModal: true, isModal: true,
actions: [ actions: [
@@ -95,15 +95,15 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
autoScrollBodyContent={true} autoScrollBodyContent={true}
onRequestClose={this._onCloseDialog.bind(this)} onRequestClose={this._onCloseDialog.bind(this)}
> >
{this.state.assetView === AssetViews.ASSET_PICKER && this._renderAssetPicker()} {this.state.assetView === AssetViews.AssetPicker && this._renderAssetPicker()}
{this.state.assetView === AssetViews.NEW_TOKEN_FORM && ( {this.state.assetView === AssetViews.NewTokenForm && (
<NewTokenForm <NewTokenForm
blockchain={this.props.blockchain} blockchain={this.props.blockchain}
onNewTokenSubmitted={this._onNewTokenSubmitted.bind(this)} onNewTokenSubmitted={this._onNewTokenSubmitted.bind(this)}
tokenByAddress={this.props.tokenByAddress} tokenByAddress={this.props.tokenByAddress}
/> />
)} )}
{this.state.assetView === AssetViews.CONFIRM_TRACK_TOKEN && this._renderConfirmTrackToken()} {this.state.assetView === AssetViews.ConfirmTrackToken && this._renderConfirmTrackToken()}
</Dialog> </Dialog>
); );
} }
@@ -138,19 +138,19 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
const allTokens = _.values(this.props.tokenByAddress); const allTokens = _.values(this.props.tokenByAddress);
// filter tokens based on visibility specified in props, do not show ZRX or ETHER as tracked or untracked // filter tokens based on visibility specified in props, do not show ZRX or ETHER as tracked or untracked
const filteredTokens = const filteredTokens =
this.props.tokenVisibility === TokenVisibility.ALL this.props.tokenVisibility === TokenVisibility.All
? allTokens ? allTokens
: _.filter(allTokens, token => { : _.filter(allTokens, token => {
return ( return (
token.symbol !== constants.ZRX_TOKEN_SYMBOL && token.symbol !== constants.ZRX_TOKEN_SYMBOL &&
token.symbol !== constants.ETHER_TOKEN_SYMBOL && token.symbol !== constants.ETHER_TOKEN_SYMBOL &&
((this.props.tokenVisibility === TokenVisibility.TRACKED && utils.isTokenTracked(token)) || ((this.props.tokenVisibility === TokenVisibility.Tracked && utils.isTokenTracked(token)) ||
(this.props.tokenVisibility === TokenVisibility.UNTRACKED && (this.props.tokenVisibility === TokenVisibility.Untracked &&
!utils.isTokenTracked(token))) !utils.isTokenTracked(token)))
); );
}); });
// if we are showing tracked tokens, sort by date added, otherwise sort by symbol // if we are showing tracked tokens, sort by date added, otherwise sort by symbol
const sortKey = this.props.tokenVisibility === TokenVisibility.TRACKED ? 'trackedTimestamp' : 'symbol'; const sortKey = this.props.tokenVisibility === TokenVisibility.Tracked ? 'trackedTimestamp' : 'symbol';
const sortedTokens = filteredTokens.sort(firstBy(sortKey)); const sortedTokens = filteredTokens.sort(firstBy(sortKey));
if (_.isEmpty(sortedTokens)) { if (_.isEmpty(sortedTokens)) {
return <div className="mx-auto p4 h2">No tokens to remove.</div>; return <div className="mx-auto p4 h2">No tokens to remove.</div>;
@@ -188,7 +188,7 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
cursor: 'pointer', cursor: 'pointer',
opacity: isHovered ? 0.6 : 1, opacity: isHovered ? 0.6 : 1,
}; };
if (this.props.tokenVisibility !== TokenVisibility.TRACKED) { if (this.props.tokenVisibility !== TokenVisibility.Tracked) {
gridTiles.push( gridTiles.push(
<div <div
key={otherTokenKey} key={otherTokenKey}
@@ -222,7 +222,7 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
} }
private _onCloseDialog(): void { private _onCloseDialog(): void {
this.setState({ this.setState({
assetView: AssetViews.ASSET_PICKER, assetView: AssetViews.AssetPicker,
}); });
this.props.onTokenChosen(this.props.currentTokenAddress); this.props.onTokenChosen(this.props.currentTokenAddress);
} }
@@ -232,21 +232,21 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
this.props.onTokenChosen(tokenAddress); this.props.onTokenChosen(tokenAddress);
} else { } else {
this.setState({ this.setState({
assetView: AssetViews.CONFIRM_TRACK_TOKEN, assetView: AssetViews.ConfirmTrackToken,
chosenTrackTokenAddress: tokenAddress, chosenTrackTokenAddress: tokenAddress,
}); });
} }
} }
private _onCustomAssetChosen(): void { private _onCustomAssetChosen(): void {
this.setState({ this.setState({
assetView: AssetViews.NEW_TOKEN_FORM, assetView: AssetViews.NewTokenForm,
}); });
} }
private _onNewTokenSubmitted(newToken: Token): void { private _onNewTokenSubmitted(newToken: Token): void {
trackedTokenStorage.addTrackedTokenToUser(this.props.userAddress, this.props.networkId, newToken); trackedTokenStorage.addTrackedTokenToUser(this.props.userAddress, this.props.networkId, newToken);
this.props.dispatcher.addTokenToTokenByAddress(newToken); this.props.dispatcher.addTokenToTokenByAddress(newToken);
this.setState({ this.setState({
assetView: AssetViews.ASSET_PICKER, assetView: AssetViews.AssetPicker,
}); });
this.props.onTokenChosen(newToken.address); this.props.onTokenChosen(newToken.address);
} }
@@ -254,7 +254,7 @@ export class AssetPicker extends React.Component<AssetPickerProps, AssetPickerSt
const resetState: AssetPickerState = { const resetState: AssetPickerState = {
...this.state, ...this.state,
isAddingTokenToTracked: false, isAddingTokenToTracked: false,
assetView: AssetViews.ASSET_PICKER, assetView: AssetViews.AssetPicker,
chosenTrackTokenAddress: undefined, chosenTrackTokenAddress: undefined,
}; };
if (!didUserAcceptTracking) { if (!didUserAcceptTracking) {

20
packages/website/ts/components/generate_order/generate_order_form.tsx
View File

@@ -36,9 +36,9 @@ import { errorReporter } from 'ts/utils/error_reporter';
import { utils } from 'ts/utils/utils'; import { utils } from 'ts/utils/utils';
enum SigningState { enum SigningState {
UNSIGNED, Unsigned,
SIGNING, Signing,
SIGNED, Signed,
} }
interface GenerateOrderFormProps { interface GenerateOrderFormProps {
@@ -76,7 +76,7 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
this.state = { this.state = {
globalErrMsg: '', globalErrMsg: '',
shouldShowIncompleteErrs: false, shouldShowIncompleteErrs: false,
signingState: SigningState.UNSIGNED, signingState: SigningState.Unsigned,
}; };
} }
public componentDidMount(): void { public componentDidMount(): void {
@@ -207,7 +207,7 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
/> />
</div> </div>
{this.state.globalErrMsg !== '' && ( {this.state.globalErrMsg !== '' && (
<Alert type={AlertTypes.ERROR} message={this.state.globalErrMsg} /> <Alert type={AlertTypes.Error} message={this.state.globalErrMsg} />
)} )}
</div> </div>
</div> </div>
@@ -215,7 +215,7 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
title="Order JSON" title="Order JSON"
titleStyle={{ fontWeight: 100 }} titleStyle={{ fontWeight: 100 }}
modal={false} modal={false}
open={this.state.signingState === SigningState.SIGNED} open={this.state.signingState === SigningState.Signed}
onRequestClose={this._onCloseOrderJSONDialog.bind(this)} onRequestClose={this._onCloseOrderJSONDialog.bind(this)}
> >
<OrderJSON <OrderJSON
@@ -247,7 +247,7 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
// orderHash will not collide with the previously generated orderHash. // orderHash will not collide with the previously generated orderHash.
this.props.dispatcher.updateOrderSalt(generatePseudoRandomSalt()); this.props.dispatcher.updateOrderSalt(generatePseudoRandomSalt());
this.setState({ this.setState({
signingState: SigningState.UNSIGNED, signingState: SigningState.Unsigned,
}); });
} }
private async _onSignClickedAsync(): Promise<boolean> { private async _onSignClickedAsync(): Promise<boolean> {
@@ -305,13 +305,13 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
} }
private async _signTransactionAsync(): Promise<PortalOrder | undefined> { private async _signTransactionAsync(): Promise<PortalOrder | undefined> {
this.setState({ this.setState({
signingState: SigningState.SIGNING, signingState: SigningState.Signing,
}); });
const exchangeAddress = this.props.blockchain.getExchangeContractAddressIfExists(); const exchangeAddress = this.props.blockchain.getExchangeContractAddressIfExists();
if (_.isUndefined(exchangeAddress)) { if (_.isUndefined(exchangeAddress)) {
this.props.dispatcher.updateShouldBlockchainErrDialogBeOpen(true); this.props.dispatcher.updateShouldBlockchainErrDialogBeOpen(true);
this.setState({ this.setState({
signingState: SigningState.UNSIGNED, signingState: SigningState.Unsigned,
}); });
return undefined; return undefined;
} }
@@ -371,7 +371,7 @@ export class GenerateOrderForm extends React.Component<GenerateOrderFormProps, G
} }
} }
this.setState({ this.setState({
signingState: globalErrMsg === '' ? SigningState.SIGNED : SigningState.UNSIGNED, signingState: globalErrMsg === '' ? SigningState.Signed : SigningState.Unsigned,
globalErrMsg, globalErrMsg,
}); });
return order; return order;

2
packages/website/ts/components/generate_order/new_token_form.tsx
View File

@@ -93,7 +93,7 @@ export class NewTokenForm extends React.Component<NewTokenFormProps, NewTokenFor
onClickAsyncFn={this._onAddNewTokenClickAsync.bind(this)} onClickAsyncFn={this._onAddNewTokenClickAsync.bind(this)}
/> />
</div> </div>
{this.state.globalErrMsg !== '' && <Alert type={AlertTypes.ERROR} message={this.state.globalErrMsg} />} {this.state.globalErrMsg !== '' && <Alert type={AlertTypes.Error} message={this.state.globalErrMsg} />}
</div> </div>
); );
} }

2
packages/website/ts/components/inputs/allowance_state_toggle.tsx
View File

@@ -150,7 +150,7 @@ export class AllowanceStateToggle extends React.Component<AllowanceStateTogglePr
} }
logUtils.log(`Unexpected error encountered: ${err}`); logUtils.log(`Unexpected error encountered: ${err}`);
logUtils.log(err.stack); logUtils.log(err.stack);
this.props.onErrorOccurred(BalanceErrs.allowanceSettingFailed); this.props.onErrorOccurred(BalanceErrs.AllowanceSettingFailed);
errorReporter.report(err); errorReporter.report(err);
} }
} }

4
packages/website/ts/components/portal/portal.tsx
View File

@@ -229,8 +229,8 @@ export class Portal extends React.Component<PortalProps, PortalState> {
const isAssetPickerDialogOpen = this.state.tokenManagementState !== TokenManagementState.None; const isAssetPickerDialogOpen = this.state.tokenManagementState !== TokenManagementState.None;
const tokenVisibility = const tokenVisibility =
this.state.tokenManagementState === TokenManagementState.Add this.state.tokenManagementState === TokenManagementState.Add
? TokenVisibility.UNTRACKED ? TokenVisibility.Untracked
: TokenVisibility.TRACKED; : TokenVisibility.Tracked;
return ( return (
<Container> <Container>
<MetaTags title={DOCUMENT_TITLE} description={DOCUMENT_DESCRIPTION} /> <MetaTags title={DOCUMENT_TITLE} description={DOCUMENT_DESCRIPTION} />

22
packages/website/ts/components/token_balances.tsx
View File

@@ -303,7 +303,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
currentTokenAddress={''} currentTokenAddress={''}
onTokenChosen={this._onAssetTokenPicked.bind(this)} onTokenChosen={this._onAssetTokenPicked.bind(this)}
tokenByAddress={this.props.tokenByAddress} tokenByAddress={this.props.tokenByAddress}
tokenVisibility={this.state.isAddingToken ? TokenVisibility.UNTRACKED : TokenVisibility.TRACKED} tokenVisibility={this.state.isAddingToken ? TokenVisibility.Untracked : TokenVisibility.Tracked}
/> />
</div> </div>
); );
@@ -439,7 +439,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
} }
private _onSendFailed(): void { private _onSendFailed(): void {
this.setState({ this.setState({
errorType: BalanceErrs.sendFailed, errorType: BalanceErrs.SendFailed,
}); });
} }
private _renderAmount(amount: BigNumber, decimals: number): React.ReactNode { private _renderAmount(amount: BigNumber, decimals: number): React.ReactNode {
@@ -460,7 +460,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
} }
private _renderErrorDialogBody(): React.ReactNode { private _renderErrorDialogBody(): React.ReactNode {
switch (this.state.errorType) { switch (this.state.errorType) {
case BalanceErrs.incorrectNetworkForFaucet: case BalanceErrs.IncorrectNetworkForFaucet:
return ( return (
<div> <div>
Our faucet can only send test Ether to addresses on testnets. Please make sure you are connected Our faucet can only send test Ether to addresses on testnets. Please make sure you are connected
@@ -468,7 +468,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
</div> </div>
); );
case BalanceErrs.faucetRequestFailed: case BalanceErrs.FaucetRequestFailed:
return ( return (
<div> <div>
An unexpected error occurred while trying to request test Ether from our faucet. Please refresh An unexpected error occurred while trying to request test Ether from our faucet. Please refresh
@@ -476,13 +476,13 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
</div> </div>
); );
case BalanceErrs.faucetQueueIsFull: case BalanceErrs.FaucetQueueIsFull:
return <div>Our test Ether faucet queue is full. Please try requesting test Ether again later.</div>; return <div>Our test Ether faucet queue is full. Please try requesting test Ether again later.</div>;
case BalanceErrs.mintingFailed: case BalanceErrs.MintingFailed:
return <div>Minting your test tokens failed unexpectedly. Please refresh the page and try again.</div>; return <div>Minting your test tokens failed unexpectedly. Please refresh the page and try again.</div>;
case BalanceErrs.allowanceSettingFailed: case BalanceErrs.AllowanceSettingFailed:
return ( return (
<div> <div>
An unexpected error occurred while trying to set your test token allowance. Please refresh the An unexpected error occurred while trying to set your test token allowance. Please refresh the
@@ -521,7 +521,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
logUtils.log(`Unexpected error encountered: ${err}`); logUtils.log(`Unexpected error encountered: ${err}`);
logUtils.log(err.stack); logUtils.log(err.stack);
this.setState({ this.setState({
errorType: BalanceErrs.mintingFailed, errorType: BalanceErrs.MintingFailed,
}); });
errorReporter.report(err); errorReporter.report(err);
return false; return false;
@@ -537,7 +537,7 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
// from, we must show user an error message // from, we must show user an error message
if (!utils.isTestNetwork(this.props.blockchain.networkId)) { if (!utils.isTestNetwork(this.props.blockchain.networkId)) {
this.setState({ this.setState({
errorType: BalanceErrs.incorrectNetworkForFaucet, errorType: BalanceErrs.IncorrectNetworkForFaucet,
}); });
return false; return false;
} }
@@ -553,8 +553,8 @@ export class TokenBalances extends React.Component<TokenBalancesProps, TokenBala
logUtils.log(`Unexpected status code: ${response.status} -> ${responseBody}`); logUtils.log(`Unexpected status code: ${response.status} -> ${responseBody}`);
const errorType = const errorType =
response.status === constants.UNAVAILABLE_STATUS response.status === constants.UNAVAILABLE_STATUS
? BalanceErrs.faucetQueueIsFull ? BalanceErrs.FaucetQueueIsFull
: BalanceErrs.faucetRequestFailed; : BalanceErrs.FaucetRequestFailed;
this.setState({ this.setState({
errorType, errorType,
}); });

2
packages/website/ts/components/ui/alert.tsx
View File

@@ -8,7 +8,7 @@ interface AlertProps {
} }
export const Alert = (props: AlertProps) => { export const Alert = (props: AlertProps) => {
const isAlert = props.type === AlertTypes.ERROR; const isAlert = props.type === AlertTypes.Error;
const errMsgStyles = { const errMsgStyles = {
background: isAlert ? colors.red200 : colors.lightestGreen, background: isAlert ? colors.red200 : colors.lightestGreen,
color: colors.white, color: colors.white,

24
packages/website/ts/components/ui/lifecycle_raised_button.tsx
View File

@@ -6,9 +6,9 @@ import * as React from 'react';
const COMPLETE_STATE_SHOW_LENGTH_MS = 2000; const COMPLETE_STATE_SHOW_LENGTH_MS = 2000;
enum ButtonState { enum ButtonState {
READY, Ready,
LOADING, Loading,
COMPLETE, Complete,
} }
interface LifeCycleRaisedButtonProps { interface LifeCycleRaisedButtonProps {
@@ -38,7 +38,7 @@ export class LifeCycleRaisedButton extends React.Component<LifeCycleRaisedButton
constructor(props: LifeCycleRaisedButtonProps) { constructor(props: LifeCycleRaisedButtonProps) {
super(props); super(props);
this.state = { this.state = {
buttonState: ButtonState.READY, buttonState: ButtonState.Ready,
}; };
} }
public componentWillUnmount(): void { public componentWillUnmount(): void {
@@ -52,13 +52,13 @@ export class LifeCycleRaisedButton extends React.Component<LifeCycleRaisedButton
let label; let label;
switch (this.state.buttonState) { switch (this.state.buttonState) {
case ButtonState.READY: case ButtonState.Ready:
label = this.props.labelReady; label = this.props.labelReady;
break; break;
case ButtonState.LOADING: case ButtonState.Loading:
label = this.props.labelLoading; label = this.props.labelLoading;
break; break;
case ButtonState.COMPLETE: case ButtonState.Complete:
label = this.props.labelComplete; label = this.props.labelComplete;
break; break;
default: default:
@@ -72,13 +72,13 @@ export class LifeCycleRaisedButton extends React.Component<LifeCycleRaisedButton
backgroundColor={this.props.backgroundColor} backgroundColor={this.props.backgroundColor}
labelColor={this.props.labelColor} labelColor={this.props.labelColor}
onClick={this.onClickAsync.bind(this)} onClick={this.onClickAsync.bind(this)}
disabled={this.props.isDisabled || this.state.buttonState !== ButtonState.READY} disabled={this.props.isDisabled || this.state.buttonState !== ButtonState.Ready}
/> />
); );
} }
public async onClickAsync(): Promise<void> { public async onClickAsync(): Promise<void> {
this.setState({ this.setState({
buttonState: ButtonState.LOADING, buttonState: ButtonState.Loading,
}); });
const didSucceed = await this.props.onClickAsyncFn(); const didSucceed = await this.props.onClickAsyncFn();
if (this._didUnmount) { if (this._didUnmount) {
@@ -86,16 +86,16 @@ export class LifeCycleRaisedButton extends React.Component<LifeCycleRaisedButton
} }
if (didSucceed) { if (didSucceed) {
this.setState({ this.setState({
buttonState: ButtonState.COMPLETE, buttonState: ButtonState.Complete,
}); });
this._buttonTimeoutId = window.setTimeout(() => { this._buttonTimeoutId = window.setTimeout(() => {
this.setState({ this.setState({
buttonState: ButtonState.READY, buttonState: ButtonState.Ready,
}); });
}, COMPLETE_STATE_SHOW_LENGTH_MS); }, COMPLETE_STATE_SHOW_LENGTH_MS);
} else { } else {
this.setState({ this.setState({
buttonState: ButtonState.READY, buttonState: ButtonState.Ready,
}); });
} }
} }

36
packages/website/ts/types.ts
View File

@@ -83,12 +83,12 @@ export interface Fill {
} }
export enum BalanceErrs { export enum BalanceErrs {
incorrectNetworkForFaucet, IncorrectNetworkForFaucet,
faucetRequestFailed, FaucetRequestFailed,
faucetQueueIsFull, FaucetQueueIsFull,
mintingFailed, MintingFailed,
sendFailed, SendFailed,
allowanceSettingFailed, AllowanceSettingFailed,
} }
export enum ActionTypes { export enum ActionTypes {
@@ -209,8 +209,8 @@ export enum ScreenWidths {
} }
export enum AlertTypes { export enum AlertTypes {
ERROR, Error,
SUCCESS, Success,
} }
export enum BlockchainErrs { export enum BlockchainErrs {
@@ -228,11 +228,11 @@ export enum BlockchainCallErrs {
} }
export enum Environments { export enum Environments {
DEVELOPMENT = 'DEVELOPMENT', Development = 'DEVELOPMENT',
DOGFOOD = 'DOGFOOD', Dogfood = 'DOGFOOD',
STAGING = 'STAGING', Staging = 'STAGING',
PRODUCTION = 'PRODUCTION', Production = 'PRODUCTION',
UNKNOWN = 'UNKNOWN', Unknown = 'UNKNOWN',
} }
export type ContractInstance = any; // TODO: add type definition for Contract export type ContractInstance = any; // TODO: add type definition for Contract
@@ -323,9 +323,9 @@ export interface DialogConfigs {
} }
export enum TokenVisibility { export enum TokenVisibility {
ALL = 'ALL', All = 'ALL',
UNTRACKED = 'UNTRACKED', Untracked = 'UNTRACKED',
TRACKED = 'TRACKED', Tracked = 'TRACKED',
} }
export interface VersionToFilePath { export interface VersionToFilePath {
@@ -350,7 +350,7 @@ export enum WebsitePaths {
Docs = '/docs', Docs = '/docs',
ZeroExJs = '/docs/0x.js', ZeroExJs = '/docs/0x.js',
Home = '/', Home = '/',
FAQ = '/faq', FAQ = '/faq', // tslint:disable-line:enum-naming
About = '/about', About = '/about',
AboutMission = '/about/mission', AboutMission = '/about/mission',
AboutTeam = '/about/team', AboutTeam = '/about/team',
@@ -629,7 +629,7 @@ export enum BrowserType {
export enum OperatingSystemType { export enum OperatingSystemType {
Android = 'Android', Android = 'Android',
iOS = 'iOS', iOS = 'iOS', // tslint:disable-line:enum-naming
Mac = 'Mac', Mac = 'Mac',
Windows = 'Windows', Windows = 'Windows',
WindowsPhone = 'WindowsPhone', WindowsPhone = 'WindowsPhone',

10
packages/website/ts/utils/utils.ts
View File

@@ -342,18 +342,18 @@ export const utils = {
}, },
getEnvironment(): Environments { getEnvironment(): Environments {
if (utils.isDogfood()) { if (utils.isDogfood()) {
return Environments.DOGFOOD; return Environments.Dogfood;
} }
if (utils.isDevelopment()) { if (utils.isDevelopment()) {
return Environments.DEVELOPMENT; return Environments.Development;
} }
if (utils.isStaging()) { if (utils.isStaging()) {
return Environments.STAGING; return Environments.Staging;
} }
if (utils.isProduction()) { if (utils.isProduction()) {
return Environments.PRODUCTION; return Environments.Production;
} }
return Environments.UNKNOWN; return Environments.Unknown;
}, },
getEthToken(tokenByAddress: TokenByAddress): Token { getEthToken(tokenByAddress: TokenByAddress): Token {
return utils.getTokenBySymbol(constants.ETHER_TOKEN_SYMBOL, tokenByAddress); return utils.getTokenBySymbol(constants.ETHER_TOKEN_SYMBOL, tokenByAddress);