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

Fix exchange package build

Browse Source
This commit is contained in:
Amir Bandeali 2019-05-23 18:56:03 -05:00
parent 7cff9ba86a
commit c96a81e319
4 changed files with 57 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
contracts/exchange/contracts/examples/ExchangeWrapper.sol
View File

@ -40,10 +40,12 @@ contract ExchangeWrapper {
/// and senderAddress equal to this contract. /// and senderAddress equal to this contract.
/// @param targetOrderEpoch Orders created with a salt less or equal to this value will be cancelled. /// @param targetOrderEpoch Orders created with a salt less or equal to this value will be cancelled.
/// @param salt Arbitrary value to gaurantee uniqueness of 0x transaction hash. /// @param salt Arbitrary value to gaurantee uniqueness of 0x transaction hash.
/// @param transactionExpirationTimeSeconds Timestamp in seconds ar which ZeroExTransaction expires.
/// @param makerSignature Proof that maker wishes to call this function with given params. /// @param makerSignature Proof that maker wishes to call this function with given params.
function cancelOrdersUpTo( function cancelOrdersUpTo(
uint256 targetOrderEpoch, uint256 targetOrderEpoch,
uint256 salt, uint256 salt,
uint256 transactionExpirationTimeSeconds,
bytes calldata makerSignature bytes calldata makerSignature
) )
external external
@ -58,6 +60,7 @@ contract ExchangeWrapper {
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({ LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt, salt: salt,
expirationTimeSeconds: transactionExpirationTimeSeconds,
data: data, data: data,
signerAddress: makerAddress signerAddress: makerAddress
}); });
@ -70,12 +73,14 @@ contract ExchangeWrapper {
/// @param order Order struct containing order specifications. /// @param order Order struct containing order specifications.
/// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
/// @param salt Arbitrary value to gaurantee uniqueness of 0x transaction hash. /// @param salt Arbitrary value to gaurantee uniqueness of 0x transaction hash.
/// @param transactionExpirationTimeSeconds Timestamp in seconds ar which ZeroExTransaction expires.
/// @param orderSignature Proof that order has been created by maker. /// @param orderSignature Proof that order has been created by maker.
/// @param takerSignature Proof that taker wishes to call this function with given params. /// @param takerSignature Proof that taker wishes to call this function with given params.
function fillOrder( function fillOrder(
LibOrder.Order memory order, LibOrder.Order memory order,
uint256 takerAssetFillAmount, uint256 takerAssetFillAmount,
uint256 salt, uint256 salt,
uint256 transactionExpirationTimeSeconds,
bytes memory orderSignature, bytes memory orderSignature,
bytes memory takerSignature bytes memory takerSignature
) )
@ -93,6 +98,7 @@ contract ExchangeWrapper {
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({ LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt, salt: salt,
expirationTimeSeconds: transactionExpirationTimeSeconds,
data: data, data: data,
signerAddress: takerAddress signerAddress: takerAddress
}); });

2
contracts/exchange/contracts/examples/Whitelist.sol
View File

@ -28,7 +28,6 @@ import "@0x/contracts-utils/contracts/src/Ownable.sol";
contract Whitelist is contract Whitelist is
Ownable Ownable
{ {
// Mapping of address => whitelist status. // Mapping of address => whitelist status.
mapping (address => bool) public isWhitelisted; mapping (address => bool) public isWhitelisted;
@ -129,6 +128,7 @@ contract Whitelist is
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({ LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt, salt: salt,
data: data, data: data,
expirationTimeSeconds: uint256(-1),
signerAddress: takerAddress signerAddress: takerAddress
}); });

84
contracts/exchange/test/transactions.ts
View File

@ -166,7 +166,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should revert if signature is invalid and not called by signer`, async () => { it(`${fnName} should revert if signature is invalid and not called by signer`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const v = ethUtil.toBuffer(transaction.signature.slice(0, 4)); const v = ethUtil.toBuffer(transaction.signature.slice(0, 4));
const invalidR = ethUtil.sha3('invalidR'); const invalidR = ethUtil.sha3('invalidR');
const invalidS = ethUtil.sha3('invalidS'); const invalidS = ethUtil.sha3('invalidS');
@ -186,7 +186,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should be successful if signed by taker and called by sender`, async () => { it(`${fnName} should be successful if signed by taker and called by sender`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync( const transactionReceipt = await exchangeWrapper.executeTransactionAsync(
transaction, transaction,
senderAddress, senderAddress,
@ -211,7 +211,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should be successful if called by taker without a transaction signature`, async () => { it(`${fnName} should be successful if called by taker without a transaction signature`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const fillLogs = transactionReceipt.logs.filter( const fillLogs = transactionReceipt.logs.filter(
@ -235,7 +235,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync(); const order = await orderFactory.newSignedOrderAsync();
const orders = [order]; const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const returnData = await exchangeInstance.executeTransaction.callAsync( const returnData = await exchangeInstance.executeTransaction.callAsync(
transaction, transaction,
transaction.signature, transaction.signature,
@ -259,7 +259,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should revert if transaction has already been executed`, async () => { it(`${fnName} should revert if transaction has already been executed`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const expectedError = new ExchangeRevertErrors.TransactionError( const expectedError = new ExchangeRevertErrors.TransactionError(
@ -272,13 +272,13 @@ describe('Exchange transactions', () => {
it(`${fnName} should revert and rethrow error if executeTransaction is called recursively with a signature`, async () => { it(`${fnName} should revert and rethrow error if executeTransaction is called recursively with a signature`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData( const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData(
transaction, transaction,
transaction.signature, transaction.signature,
); );
const recursiveTransaction = takerTransactionFactory.newSignedTransaction(recursiveData); const recursiveTransaction = await takerTransactionFactory.newSignedTransactionAsync(recursiveData);
const recursiveTransactionHashHex = transactionHashUtils.getTransactionHashHex( const recursiveTransactionHashHex = transactionHashUtils.getTransactionHashHex(
recursiveTransaction, recursiveTransaction,
); );
@ -296,12 +296,12 @@ describe('Exchange transactions', () => {
it(`${fnName} should be successful if executeTransaction is called recursively by taker without a signature`, async () => { it(`${fnName} should be successful if executeTransaction is called recursively by taker without a signature`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData( const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData(
transaction, transaction,
constants.NULL_BYTES, constants.NULL_BYTES,
); );
const recursiveTransaction = takerTransactionFactory.newSignedTransaction(recursiveData); const recursiveTransaction = await takerTransactionFactory.newSignedTransactionAsync(recursiveData);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync( const transactionReceipt = await exchangeWrapper.executeTransactionAsync(
recursiveTransaction, recursiveTransaction,
takerAddress, takerAddress,
@ -336,7 +336,7 @@ describe('Exchange transactions', () => {
order.signature = constants.NULL_BYTES; order.signature = constants.NULL_BYTES;
const orders = [order]; const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.SignatureError( const nestedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidLength, ExchangeRevertErrors.SignatureErrorCode.InvalidLength,
@ -359,7 +359,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync(); const order = await orderFactory.newSignedOrderAsync();
const orders = [order]; const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.InvalidMakerError( const nestedError = new ExchangeRevertErrors.InvalidMakerError(
orderHashUtils.getOrderHashHex(order), orderHashUtils.getOrderHashHex(order),
@ -375,7 +375,7 @@ describe('Exchange transactions', () => {
it('should be successful if signed by maker and called by sender', async () => { it('should be successful if signed by maker and called by sender', async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel', log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel',
@ -392,7 +392,7 @@ describe('Exchange transactions', () => {
it('should be successful if called by maker without a signature', async () => { it('should be successful if called by maker without a signature', async () => {
const orders = [await orderFactory.newSignedOrderAsync()]; const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
@ -415,7 +415,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders, ExchangeFunctionName.BatchCancelOrders,
orders, orders,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.InvalidMakerError( const nestedError = new ExchangeRevertErrors.InvalidMakerError(
orderHashUtils.getOrderHashHex(orders[0]), orderHashUtils.getOrderHashHex(orders[0]),
@ -434,7 +434,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders, ExchangeFunctionName.BatchCancelOrders,
orders, orders,
); );
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel', log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel',
@ -456,7 +456,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders, ExchangeFunctionName.BatchCancelOrders,
orders, orders,
); );
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
@ -478,7 +478,7 @@ describe('Exchange transactions', () => {
it('should be successful if signed by maker and called by sender', async () => { it('should be successful if signed by maker and called by sender', async () => {
const targetEpoch = constants.ZERO_AMOUNT; const targetEpoch = constants.ZERO_AMOUNT;
const data = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetEpoch); const data = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetEpoch);
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo', log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo',
@ -492,7 +492,7 @@ describe('Exchange transactions', () => {
it('should be successful if called by maker without a signature', async () => { it('should be successful if called by maker without a signature', async () => {
const targetEpoch = constants.ZERO_AMOUNT; const targetEpoch = constants.ZERO_AMOUNT;
const data = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetEpoch); const data = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetEpoch);
const transaction = makerTransactionFactory.newSignedTransaction(data); const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress);
const cancelLogs = transactionReceipt.logs.filter( const cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo', log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo',
@ -509,7 +509,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync(); const order = await orderFactory.newSignedOrderAsync();
const orderHash = orderHashUtils.getOrderHashHex(order); const orderHash = orderHashUtils.getOrderHashHex(order);
const data = exchangeInstance.preSign.getABIEncodedTransactionData(orderHash); const data = exchangeInstance.preSign.getABIEncodedTransactionData(orderHash);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
let isPreSigned = await exchangeInstance.preSigned.callAsync(orderHash, takerAddress); let isPreSigned = await exchangeInstance.preSigned.callAsync(orderHash, takerAddress);
expect(isPreSigned).to.be.eq(false); expect(isPreSigned).to.be.eq(false);
await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
@ -520,7 +520,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync(); const order = await orderFactory.newSignedOrderAsync();
const orderHash = orderHashUtils.getOrderHashHex(order); const orderHash = orderHashUtils.getOrderHashHex(order);
const data = exchangeInstance.preSign.getABIEncodedTransactionData(orderHash); const data = exchangeInstance.preSign.getABIEncodedTransactionData(orderHash);
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
let isPreSigned = await exchangeInstance.preSigned.callAsync(orderHash, takerAddress); let isPreSigned = await exchangeInstance.preSigned.callAsync(orderHash, takerAddress);
expect(isPreSigned).to.be.eq(false); expect(isPreSigned).to.be.eq(false);
@ -536,7 +536,7 @@ describe('Exchange transactions', () => {
validatorAddress, validatorAddress,
shouldApprove, shouldApprove,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter( const validatorApprovalLogs = transactionReceipt.logs.filter(
log => log =>
@ -557,7 +557,7 @@ describe('Exchange transactions', () => {
validatorAddress, validatorAddress,
shouldApprove, shouldApprove,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter( const validatorApprovalLogs = transactionReceipt.logs.filter(
@ -581,7 +581,7 @@ describe('Exchange transactions', () => {
validatorAddress, validatorAddress,
shouldApprove, shouldApprove,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter( const validatorApprovalLogs = transactionReceipt.logs.filter(
log => log =>
@ -602,7 +602,7 @@ describe('Exchange transactions', () => {
validatorAddress, validatorAddress,
shouldApprove, shouldApprove,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES; transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress); const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter( const validatorApprovalLogs = transactionReceipt.logs.filter(
@ -625,8 +625,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync(); const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]); const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]); const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2); const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync( const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2], [transaction1, transaction2],
senderAddress, senderAddress,
@ -667,8 +667,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync(); const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]); const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]); const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = takerTransactionFactory.newSignedTransaction(data2); const transaction2 = await takerTransactionFactory.newSignedTransactionAsync(data2);
transaction1.signature = constants.NULL_BYTES; transaction1.signature = constants.NULL_BYTES;
transaction2.signature = constants.NULL_BYTES; transaction2.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync( const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
@ -711,8 +711,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync(); const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]); const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]); const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2); const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
transaction2.signature = constants.NULL_BYTES; transaction2.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync( const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2], [transaction1, transaction2],
@ -754,8 +754,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync(); const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]); const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]); const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2); const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
const returnData = await exchangeInstance.batchExecuteTransactions.callAsync( const returnData = await exchangeInstance.batchExecuteTransactions.callAsync(
[transaction1, transaction2], [transaction1, transaction2],
[transaction1.signature, transaction2.signature], [transaction1.signature, transaction2.signature],
@ -784,8 +784,8 @@ describe('Exchange transactions', () => {
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [ const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [
order2, order2,
]); ]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = makerTransactionFactory.newSignedTransaction(data2); const transaction2 = await makerTransactionFactory.newSignedTransactionAsync(data2);
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync( const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2], [transaction1, transaction2],
senderAddress, senderAddress,
@ -839,8 +839,8 @@ describe('Exchange transactions', () => {
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [ const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [
order2, order2,
]); ]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1); const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = makerTransactionFactory.newSignedTransaction(data2); const transaction2 = await makerTransactionFactory.newSignedTransactionAsync(data2);
const returnData = await exchangeInstance.batchExecuteTransactions.callAsync( const returnData = await exchangeInstance.batchExecuteTransactions.callAsync(
[transaction1, transaction2], [transaction1, transaction2],
[transaction1.signature, transaction2.signature], [transaction1.signature, transaction2.signature],
@ -862,8 +862,8 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync(); const order = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [order]); const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [order]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order]); const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order]);
const transaction1 = makerTransactionFactory.newSignedTransaction(data1); const transaction1 = await makerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = takerTransactionFactory.newSignedTransaction(data2); const transaction2 = await takerTransactionFactory.newSignedTransactionAsync(data2);
const tx = exchangeWrapper.batchExecuteTransactionsAsync([transaction1, transaction2], senderAddress); const tx = exchangeWrapper.batchExecuteTransactionsAsync([transaction1, transaction2], senderAddress);
const nestedError = new ExchangeRevertErrors.OrderStatusError( const nestedError = new ExchangeRevertErrors.OrderStatusError(
orderHashUtils.getOrderHashHex(order), orderHashUtils.getOrderHashHex(order),
@ -901,7 +901,7 @@ describe('Exchange transactions', () => {
}); });
const targetOrderEpoch = orderSalt.plus(1); const targetOrderEpoch = orderSalt.plus(1);
const cancelData = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetOrderEpoch); const cancelData = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetOrderEpoch);
const cancelTransaction = makerTransactionFactory.newSignedTransaction(cancelData); const cancelTransaction = await makerTransactionFactory.newSignedTransactionAsync(cancelData);
await exchangeWrapperContract.cancelOrdersUpTo.awaitTransactionSuccessAsync( await exchangeWrapperContract.cancelOrdersUpTo.awaitTransactionSuccessAsync(
targetOrderEpoch, targetOrderEpoch,
cancelTransaction.salt, cancelTransaction.salt,
@ -916,7 +916,7 @@ describe('Exchange transactions', () => {
takerAssetFillAmount, takerAssetFillAmount,
signedOrder.signature, signedOrder.signature,
); );
const fillTransaction = takerTransactionFactory.newSignedTransaction(fillData); const fillTransaction = await takerTransactionFactory.newSignedTransactionAsync(fillData);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(fillTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(fillTransaction);
const expectedError = new ExchangeRevertErrors.TransactionExecutionError( const expectedError = new ExchangeRevertErrors.TransactionExecutionError(
@ -927,6 +927,7 @@ describe('Exchange transactions', () => {
signedOrder, signedOrder,
takerAssetFillAmount, takerAssetFillAmount,
fillTransaction.salt, fillTransaction.salt,
fillTransaction.expirationTimeSeconds,
signedOrder.signature, signedOrder.signature,
fillTransaction.signature, fillTransaction.signature,
{ from: takerAddress }, { from: takerAddress },
@ -949,13 +950,14 @@ describe('Exchange transactions', () => {
takerAssetFillAmount, takerAssetFillAmount,
signedOrder.signature, signedOrder.signature,
); );
const transaction = takerTransactionFactory.newSignedTransaction(data); const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const logDecoder = new LogDecoder(web3Wrapper, artifacts); const logDecoder = new LogDecoder(web3Wrapper, artifacts);
const transactionReceipt = await logDecoder.getTxWithDecodedLogsAsync( const transactionReceipt = await logDecoder.getTxWithDecodedLogsAsync(
await exchangeWrapperContract.fillOrder.sendTransactionAsync( await exchangeWrapperContract.fillOrder.sendTransactionAsync(
signedOrder, signedOrder,
takerAssetFillAmount, takerAssetFillAmount,
transaction.salt, transaction.salt,
transaction.expirationTimeSeconds,
signedOrder.signature, signedOrder.signature,
transaction.signature, transaction.signature,
{ from: takerAddress }, { from: takerAddress },

9
contracts/test-utils/src/transaction_factory.ts
View File

@ -1,7 +1,9 @@
import { generatePseudoRandomSalt, transactionHashUtils } from '@0x/order-utils'; import { generatePseudoRandomSalt, transactionHashUtils } from '@0x/order-utils';
import { SignatureType, SignedZeroExTransaction } from '@0x/types'; import { SignatureType, SignedZeroExTransaction } from '@0x/types';
import { BigNumber } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import { getLatestBlockTimestampAsync } from './block_timestamp';
import { signingUtils } from './signing_utils'; import { signingUtils } from './signing_utils';
export class TransactionFactory { export class TransactionFactory {
@ -16,16 +18,19 @@ export class TransactionFactory {
this._chainId = chainId; this._chainId = chainId;
this._signerBuff = ethUtil.privateToAddress(this._privateKey); this._signerBuff = ethUtil.privateToAddress(this._privateKey);
} }
public newSignedTransaction( public async newSignedTransactionAsync(
data: string, data: string,
signatureType: SignatureType = SignatureType.EthSign, signatureType: SignatureType = SignatureType.EthSign,
): SignedZeroExTransaction { ): Promise<SignedZeroExTransaction> {
const tenMinutesInSeconds = 10 * 60;
const currentBlockTimestamp = await getLatestBlockTimestampAsync();
const salt = generatePseudoRandomSalt(); const salt = generatePseudoRandomSalt();
const signerAddress = `0x${this._signerBuff.toString('hex')}`; const signerAddress = `0x${this._signerBuff.toString('hex')}`;
const transaction = { const transaction = {
salt, salt,
signerAddress, signerAddress,
data, data,
expirationTimeSeconds: new BigNumber(currentBlockTimestamp).plus(tenMinutesInSeconds),
domain: { domain: {
verifyingContractAddress: this._exchangeAddress, verifyingContractAddress: this._exchangeAddress,
chainId: this._chainId, chainId: this._chainId,