-
Notifications
You must be signed in to change notification settings - Fork 0
/
MultiSendCallOnly.sol
70 lines (68 loc) · 3.5 KB
/
MultiSendCallOnly.sol
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
// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
/**
* @title Multi Send Call Only - Allows to batch multiple transactions into one, but only calls
* @notice modified from safe-contracts repo
* @notice The guard logic is not required here as this contract doesn't support nested delegate
* calls
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
library MultiSendCallOnly {
/**
* @dev Sends multiple transactions and reverts all if one fails.
* @param transactions Encoded transactions. Each transaction is encoded as a packed bytes of
* operation has to be uint8(0) in this version (=> 1 byte),
* to as a address (=> 20 bytes),
* value as a uint256 (=> 32 bytes),
* data length as a uint256 (=> 32 bytes),
* data as bytes.
* see abi.encodePacked for more information on packed encoding
* @notice The code is for most part the same as the normal MultiSend (to keep compatibility),
* but reverts if a transaction tries to use a delegatecall.
* @notice This method is payable as delegatecalls keep the msg.value from the previous call
* If the calling method (e.g. execTransaction) received ETH this would revert otherwise
*/
function multiSend(bytes memory transactions) internal {
// solhint-disable-next-line no-inline-assembly
assembly {
let length := mload(transactions)
let i := 0x20
for {
// Pre block is not used in "while mode"
} lt(i, length) {
// Post block is not used in "while mode"
} {
// First byte of the data is the operation.
// We shift by 248 bits (256 - 8 [operation byte]) it right since mload will always
// load 32 bytes (a word).
// This will also zero out unused data.
let operation := shr(0xf8, mload(add(transactions, i)))
// We offset the load address by 1 byte (operation byte)
// We shift it right by 96 bits (256 - 160 [20 address bytes]) to right-align the
// data and zero out unused data.
let to := shr(0x60, mload(add(transactions, add(i, 0x01))))
// We offset the load address by 21 byte (operation byte + 20 address bytes)
let value := mload(add(transactions, add(i, 0x15)))
// We offset the load address by 53 byte (operation byte + 20 address bytes + 32
// value bytes)
let dataLength := mload(add(transactions, add(i, 0x35)))
// We offset the load address by 85 byte (operation byte + 20 address bytes + 32
// value bytes + 32 data length bytes)
let data := add(transactions, add(i, 0x55))
let success := 0
switch operation
case 0 { success := call(gas(), to, value, data, dataLength, 0, 0) }
// This version does not allow delegatecalls
case 1 { revert(0, 0) }
if eq(success, 0) {
let errorLength := returndatasize()
returndatacopy(0, 0, errorLength)
revert(0, errorLength)
}
// Next entry starts at 85 byte + data length
i := add(i, add(0x55, dataLength))
}
}
}
}