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.
/// @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 transactionExpirationTimeSeconds Timestamp in seconds ar which ZeroExTransaction expires.
/// @param makerSignature Proof that maker wishes to call this function with given params.
function cancelOrdersUpTo(
uint256 targetOrderEpoch,
uint256 salt,
uint256 transactionExpirationTimeSeconds,
bytes calldata makerSignature
)
external
@ -58,6 +60,7 @@ contract ExchangeWrapper {
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt,
expirationTimeSeconds: transactionExpirationTimeSeconds,
data: data,
signerAddress: makerAddress
});
@ -70,12 +73,14 @@ contract ExchangeWrapper {
/// @param order Order struct containing order specifications.
/// @param takerAssetFillAmount Desired amount of takerAsset to sell.
/// @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 takerSignature Proof that taker wishes to call this function with given params.
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
uint256 salt,
uint256 transactionExpirationTimeSeconds,
bytes memory orderSignature,
bytes memory takerSignature
)
@ -93,6 +98,7 @@ contract ExchangeWrapper {
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt,
expirationTimeSeconds: transactionExpirationTimeSeconds,
data: data,
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
Ownable
{
// Mapping of address => whitelist status.
mapping (address => bool) public isWhitelisted;
@ -129,6 +128,7 @@ contract Whitelist is
LibZeroExTransaction.ZeroExTransaction memory transaction = LibZeroExTransaction.ZeroExTransaction({
salt: salt,
data: data,
expirationTimeSeconds: uint256(-1),
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 () => {
const orders = [await orderFactory.newSignedOrderAsync()];
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 invalidR = ethUtil.sha3('invalidR');
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 () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(
transaction,
senderAddress,
@ -211,7 +211,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should be successful if called by taker without a transaction signature`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const fillLogs = transactionReceipt.logs.filter(
@ -235,7 +235,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync();
const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const returnData = await exchangeInstance.executeTransaction.callAsync(
transaction,
transaction.signature,
@ -259,7 +259,7 @@ describe('Exchange transactions', () => {
it(`${fnName} should revert if transaction has already been executed`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
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 () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData(
transaction,
transaction.signature,
);
const recursiveTransaction = takerTransactionFactory.newSignedTransaction(recursiveData);
const recursiveTransaction = await takerTransactionFactory.newSignedTransactionAsync(recursiveData);
const recursiveTransactionHashHex = transactionHashUtils.getTransactionHashHex(
recursiveTransaction,
);
@ -296,12 +296,12 @@ describe('Exchange transactions', () => {
it(`${fnName} should be successful if executeTransaction is called recursively by taker without a signature`, async () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const recursiveData = exchangeInstance.executeTransaction.getABIEncodedTransactionData(
transaction,
constants.NULL_BYTES,
);
const recursiveTransaction = takerTransactionFactory.newSignedTransaction(recursiveData);
const recursiveTransaction = await takerTransactionFactory.newSignedTransactionAsync(recursiveData);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(
recursiveTransaction,
takerAddress,
@ -336,7 +336,7 @@ describe('Exchange transactions', () => {
order.signature = constants.NULL_BYTES;
const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidLength,
@ -359,7 +359,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync();
const orders = [order];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.InvalidMakerError(
orderHashUtils.getOrderHashHex(order),
@ -375,7 +375,7 @@ describe('Exchange transactions', () => {
it('should be successful if signed by maker and called by sender', async () => {
const orders = [await orderFactory.newSignedOrderAsync()];
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 cancelLogs = transactionReceipt.logs.filter(
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 () => {
const orders = [await orderFactory.newSignedOrderAsync()];
const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
const transaction = makerTransactionFactory.newSignedTransaction(data);
const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress);
const cancelLogs = transactionReceipt.logs.filter(
@ -415,7 +415,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders,
orders,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const nestedError = new ExchangeRevertErrors.InvalidMakerError(
orderHashUtils.getOrderHashHex(orders[0]),
@ -434,7 +434,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders,
orders,
);
const transaction = makerTransactionFactory.newSignedTransaction(data);
const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel',
@ -456,7 +456,7 @@ describe('Exchange transactions', () => {
ExchangeFunctionName.BatchCancelOrders,
orders,
);
const transaction = makerTransactionFactory.newSignedTransaction(data);
const transaction = await makerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, makerAddress);
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 () => {
const targetEpoch = constants.ZERO_AMOUNT;
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 cancelLogs = transactionReceipt.logs.filter(
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 () => {
const targetEpoch = constants.ZERO_AMOUNT;
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 cancelLogs = transactionReceipt.logs.filter(
log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo',
@ -509,7 +509,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync();
const orderHash = orderHashUtils.getOrderHashHex(order);
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);
expect(isPreSigned).to.be.eq(false);
await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
@ -520,7 +520,7 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync();
const orderHash = orderHashUtils.getOrderHashHex(order);
const data = exchangeInstance.preSign.getABIEncodedTransactionData(orderHash);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
let isPreSigned = await exchangeInstance.preSigned.callAsync(orderHash, takerAddress);
expect(isPreSigned).to.be.eq(false);
@ -536,7 +536,7 @@ describe('Exchange transactions', () => {
validatorAddress,
shouldApprove,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter(
log =>
@ -557,7 +557,7 @@ describe('Exchange transactions', () => {
validatorAddress,
shouldApprove,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter(
@ -581,7 +581,7 @@ describe('Exchange transactions', () => {
validatorAddress,
shouldApprove,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, senderAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter(
log =>
@ -602,7 +602,7 @@ describe('Exchange transactions', () => {
validatorAddress,
shouldApprove,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
transaction.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.executeTransactionAsync(transaction, takerAddress);
const validatorApprovalLogs = transactionReceipt.logs.filter(
@ -625,8 +625,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2],
senderAddress,
@ -667,8 +667,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = takerTransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await takerTransactionFactory.newSignedTransactionAsync(data2);
transaction1.signature = constants.NULL_BYTES;
transaction2.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
@ -711,8 +711,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
transaction2.signature = constants.NULL_BYTES;
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2],
@ -754,8 +754,8 @@ describe('Exchange transactions', () => {
const order2 = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order1]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order2]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = taker2TransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await taker2TransactionFactory.newSignedTransactionAsync(data2);
const returnData = await exchangeInstance.batchExecuteTransactions.callAsync(
[transaction1, transaction2],
[transaction1.signature, transaction2.signature],
@ -784,8 +784,8 @@ describe('Exchange transactions', () => {
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [
order2,
]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = makerTransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await makerTransactionFactory.newSignedTransactionAsync(data2);
const transactionReceipt = await exchangeWrapper.batchExecuteTransactionsAsync(
[transaction1, transaction2],
senderAddress,
@ -839,8 +839,8 @@ describe('Exchange transactions', () => {
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [
order2,
]);
const transaction1 = takerTransactionFactory.newSignedTransaction(data1);
const transaction2 = makerTransactionFactory.newSignedTransaction(data2);
const transaction1 = await takerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await makerTransactionFactory.newSignedTransactionAsync(data2);
const returnData = await exchangeInstance.batchExecuteTransactions.callAsync(
[transaction1, transaction2],
[transaction1.signature, transaction2.signature],
@ -862,8 +862,8 @@ describe('Exchange transactions', () => {
const order = await orderFactory.newSignedOrderAsync();
const data1 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, [order]);
const data2 = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.FillOrder, [order]);
const transaction1 = makerTransactionFactory.newSignedTransaction(data1);
const transaction2 = takerTransactionFactory.newSignedTransaction(data2);
const transaction1 = await makerTransactionFactory.newSignedTransactionAsync(data1);
const transaction2 = await takerTransactionFactory.newSignedTransactionAsync(data2);
const tx = exchangeWrapper.batchExecuteTransactionsAsync([transaction1, transaction2], senderAddress);
const nestedError = new ExchangeRevertErrors.OrderStatusError(
orderHashUtils.getOrderHashHex(order),
@ -901,7 +901,7 @@ describe('Exchange transactions', () => {
});
const targetOrderEpoch = orderSalt.plus(1);
const cancelData = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(targetOrderEpoch);
const cancelTransaction = makerTransactionFactory.newSignedTransaction(cancelData);
const cancelTransaction = await makerTransactionFactory.newSignedTransactionAsync(cancelData);
await exchangeWrapperContract.cancelOrdersUpTo.awaitTransactionSuccessAsync(
targetOrderEpoch,
cancelTransaction.salt,
@ -916,7 +916,7 @@ describe('Exchange transactions', () => {
takerAssetFillAmount,
signedOrder.signature,
);
const fillTransaction = takerTransactionFactory.newSignedTransaction(fillData);
const fillTransaction = await takerTransactionFactory.newSignedTransactionAsync(fillData);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(fillTransaction);
const expectedError = new ExchangeRevertErrors.TransactionExecutionError(
@ -927,6 +927,7 @@ describe('Exchange transactions', () => {
signedOrder,
takerAssetFillAmount,
fillTransaction.salt,
fillTransaction.expirationTimeSeconds,
signedOrder.signature,
fillTransaction.signature,
{ from: takerAddress },
@ -949,13 +950,14 @@ describe('Exchange transactions', () => {
takerAssetFillAmount,
signedOrder.signature,
);
const transaction = takerTransactionFactory.newSignedTransaction(data);
const transaction = await takerTransactionFactory.newSignedTransactionAsync(data);
const logDecoder = new LogDecoder(web3Wrapper, artifacts);
const transactionReceipt = await logDecoder.getTxWithDecodedLogsAsync(
await exchangeWrapperContract.fillOrder.sendTransactionAsync(
signedOrder,
takerAssetFillAmount,
transaction.salt,
transaction.expirationTimeSeconds,
signedOrder.signature,
transaction.signature,
{ from: takerAddress },

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

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