1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
Copyright 2017 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.4.19;
pragma experimental ABIEncoderV2;
import './mixins/MExchangeCore.sol';
import "../../utils/SafeMath/SafeMath.sol";
/// @dev Consumes MExchangeCore
contract MixinWrapperFunctions is
MExchangeCore,
SafeMath
{
function fillOrKillOrder(
address[5] orderAddresses,
uint[6] orderValues,
uint takerTokenFillAmount,
bytes signature)
public
{
require(fillOrder(
orderAddresses,
orderValues,
takerTokenFillAmount,
signature
) == takerTokenFillAmount);
}
/// @dev Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert.
/// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
/// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
/// @param takerTokenFillAmount Desired amount of takerToken to fill.
/// @return Success if the transaction did not revert.
/// @return Total amount of takerToken filled in trade.
function fillOrderNoThrow(
address[5] orderAddresses,
uint256[6] orderValues,
uint256 takerTokenFillAmount,
bytes signature)
public
returns (bool success, uint256 takerTokenFilledAmount)
{
bytes4 FILL_ORDER_FUNCTION_SIGNATURE = bytes4(keccak256("fillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)"));
assembly {
let x := mload(0x40) // free memory pointer
mstore(x, FILL_ORDER_FUNCTION_SIGNATURE)
// first 32 bytes of a dynamic in-memory array contains length
mstore(add(x, 4), add(orderAddresses, 32)) // maker
mstore(add(x, 36), add(orderAddresses, 64)) // taker
mstore(add(x, 68), add(orderAddresses, 96)) // makerToken
mstore(add(x, 100), add(orderAddresses, 128)) // takerToken
mstore(add(x, 132), add(orderAddresses, 160)) // feeRecipient
mstore(add(x, 164), add(orderValues, 32)) // makerTokenAmount
mstore(add(x, 196), add(orderValues, 64)) // takerTokenAmount
mstore(add(x, 228), add(orderValues, 96)) // makerFee
mstore(add(x, 260), add(orderValues, 128)) // takerFee
mstore(add(x, 292), add(orderValues, 160)) // expirationTimestampInSec
mstore(add(x, 324), add(orderValues, 192)) // salt
mstore(add(x, 356), takerTokenFillAmount)
for {
let src := signature
let dst := add(x, 388)
let end := add(add(src, mload(signature)), 32)
} lt(src, end) {
src := add(src, 32)
dst := add(dst, 32)
} {
mstore(dst, mload(src))
}
success := delegatecall(
gas, // TODO: don't send all gas, save some for returning is case of throw
address, // call this contract
x, // inputs start at x
484, // inputs are 484 bytes long (4 + 15 * 32)
x, // store output over input
32 // output is 32 bytes
)
takerTokenFilledAmount := mload(x)
}
return (success, takerTokenFilledAmount);
}
/// @dev Synchronously executes multiple calls of fillOrder in a single transaction.
/// @param orderAddresses Array of address arrays containing individual order addresses.
/// @param orderValues Array of uint256 arrays containing individual order values.
/// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
function batchFillOrders(
address[5][] orderAddresses,
uint256[6][] orderValues,
uint256[] takerTokenFillAmounts,
bytes[] signatures)
external
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
fillOrder(
orderAddresses[i],
orderValues[i],
takerTokenFillAmounts[i],
signatures[i]
);
}
}
/// @dev Synchronously executes multiple calls of fillOrKill in a single transaction.
/// @param orderAddresses Array of address arrays containing individual order addresses.
/// @param orderValues Array of uint256 arrays containing individual order values.
/// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
function batchFillOrKillOrders(
address[5][] orderAddresses,
uint[6][] orderValues,
uint[] takerTokenFillAmounts,
bytes[] signatures)
public /// Compiler crash when set to external
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
fillOrKillOrder(
orderAddresses[i],
orderValues[i],
takerTokenFillAmounts[i],
signatures[i]
);
}
}
function fillOrdersUpTo(
address[5][] orderAddresses,
uint[6][] orderValues,
uint[] takerTokenFillAmounts,
bytes[] signatures)
public /// Stack to deep when set to external
returns (uint)
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
fillOrderNoThrow(
orderAddresses[i],
orderValues[i],
takerTokenFillAmounts[i],
signatures[i]
);
}
}
/// @dev Synchronously executes multiple fill orders in a single transaction until total takerTokenFillAmount filled.
/// @param orderAddresses Array of address arrays containing individual order addresses.
/// @param orderValues Array of uint256 arrays containing individual order values.
/// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders.
/// @return Total amount of takerTokenFillAmount filled in orders.
function marketFillOrders(
address[5][] orderAddresses,
uint256[6][] orderValues,
uint256 takerTokenFillAmount,
bytes[] signatures)
external
returns (uint256 totalTakerTokenFilledAmount)
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
require(orderAddresses[i][3] == orderAddresses[0][3]); // takerToken must be the same for each order
totalTakerTokenFilledAmount = safeAdd(totalTakerTokenFilledAmount, fillOrder(
orderAddresses[i],
orderValues[i],
safeSub(takerTokenFillAmount, totalTakerTokenFilledAmount),
signatures[i]
));
if (totalTakerTokenFilledAmount == takerTokenFillAmount) break;
}
return totalTakerTokenFilledAmount;
}
/// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction until total takerTokenFillAmount filled.
/// @param orderAddresses Array of address arrays containing individual order addresses.
/// @param orderValues Array of uint256 arrays containing individual order values.
/// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders.
/// @return Total amount of takerTokenFillAmount filled in orders.
function marketFillOrdersNoThrow(
address[5][] orderAddresses,
uint256[6][] orderValues,
uint256 takerTokenFillAmount,
bytes[] signatures)
external
returns (uint256 totalTakerTokenFilledAmount)
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
require(orderAddresses[i][3] == orderAddresses[0][3]); // takerToken must be the same for each order
var (, takerTokenFilledAmount) = fillOrderNoThrow(
orderAddresses[i],
orderValues[i],
safeSub(takerTokenFillAmount, totalTakerTokenFilledAmount),
signatures[i]
);
totalTakerTokenFilledAmount = safeAdd(totalTakerTokenFilledAmount, takerTokenFilledAmount);
if (totalTakerTokenFilledAmount == takerTokenFillAmount) break;
}
return totalTakerTokenFilledAmount;
}
/// @dev Synchronously cancels multiple orders in a single transaction.
/// @param orderAddresses Array of address arrays containing individual order addresses.
/// @param orderValues Array of uint256 arrays containing individual order values.
/// @param takerTokenCancelAmounts Array of desired amounts of takerToken to cancel in orders.
function batchCancelOrders(
address[5][] orderAddresses,
uint256[6][] orderValues,
uint256[] takerTokenCancelAmounts)
external
{
for (uint256 i = 0; i < orderAddresses.length; i++) {
cancelOrder(
orderAddresses[i],
orderValues[i],
takerTokenCancelAmounts[i]
);
}
}
}
|
