1 files changed, 154 insertions, 0 deletions
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/MixinTransactions.sol b/packages/contracts/src/2.0.0/protocol/Exchange/MixinTransactions.sol
new file mode 100644
index 000000000..31f7f2847
--- /dev/null
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/MixinTransactions.sol
@@ -0,0 +1,154 @@
+/*
+
+  Copyright 2018 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.24;
+
+import "./libs/LibExchangeErrors.sol";
+import "./mixins/MSignatureValidator.sol";
+import "./mixins/MTransactions.sol";
+import "./libs/LibEIP712.sol";
+
+contract MixinTransactions is
+    LibEIP712,
+    MSignatureValidator,
+    MTransactions
+{
+
+    // Mapping of transaction hash => executed
+    // This prevents transactions from being executed more than once.
+    mapping (bytes32 => bool) public transactions;
+
+    // Address of current transaction signer
+    address public currentContextAddress;
+
+    // Hash for the EIP712 ZeroEx Transaction Schema
+    bytes32 constant EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH = keccak256(abi.encodePacked(
+        "ZeroExTransaction(",
+        "uint256 salt,",
+        "address signerAddress,",
+        "bytes data",
+        ")"
+    ));
+
+    /// @dev Calculates EIP712 hash of the Transaction.
+    /// @param salt Arbitrary number to ensure uniqueness of transaction hash.
+    /// @param signerAddress Address of transaction signer.
+    /// @param data AbiV2 encoded calldata.
+    /// @return EIP712 hash of the Transaction.
+    function hashZeroExTransaction(
+        uint256 salt,
+        address signerAddress,
+        bytes memory data
+    )
+        internal
+        pure
+        returns (bytes32 result)
+    {
+        bytes32 schemaHash = EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH;
+        bytes32 dataHash = keccak256(data);
+        // Assembly for more efficiently computing:
+        // keccak256(abi.encode(
+        //   EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH,
+        //   salt,
+        //   signerAddress,
+        //   keccak256(data)
+        //  ));
+        assembly {
+            let memPtr := mload(64)
+            mstore(memPtr, schemaHash)
+            mstore(add(memPtr, 32), salt)
+            mstore(add(memPtr, 64), and(signerAddress, 0xffffffffffffffffffffffffffffffffffffffff))
+            mstore(add(memPtr, 96), dataHash)
+            result := keccak256(memPtr, 128)
+        }
+
+        return result;
+    }
+
+    /// @dev Executes an exchange method call in the context of signer.
+    /// @param salt Arbitrary number to ensure uniqueness of transaction hash.
+    /// @param signerAddress Address of transaction signer.
+    /// @param data AbiV2 encoded calldata.
+    /// @param signature Proof of signer transaction by signer.
+    function executeTransaction(
+        uint256 salt,
+        address signerAddress,
+        bytes data,
+        bytes signature
+    )
+        external
+    {
+        // Prevent reentrancy
+        require(
+            currentContextAddress == address(0),
+            "REENTRANCY_ILLEGAL"
+        );
+
+        bytes32 transactionHash = hashEIP712Message(hashZeroExTransaction(
+            salt,
+            signerAddress,
+            data
+        ));
+
+        // Validate transaction has not been executed
+        require(
+            !transactions[transactionHash],
+            "INVALID_TX_HASH"
+        );
+
+        // Transaction always valid if signer is sender of transaction
+        if (signerAddress != msg.sender) {
+            // Validate signature
+            require(
+                isValidSignature(
+                    transactionHash,
+                    signerAddress,
+                    signature
+                ),
+                "INVALID_TX_SIGNATURE"
+            );
+
+            // Set the current transaction signer
+            currentContextAddress = signerAddress;
+        }
+
+        // Execute transaction
+        transactions[transactionHash] = true;
+        require(
+            address(this).delegatecall(data),
+            "FAILED_EXECUTION"
+        );
+
+        // Reset current transaction signer
+        // TODO: Check if gas is paid when currentContextAddress is already 0.
+        currentContextAddress = address(0);
+    }
+
+    /// @dev The current function will be called in the context of this address (either 0x transaction signer or `msg.sender`).
+    ///      If calling a fill function, this address will represent the taker.
+    ///      If calling a cancel function, this address will represent the maker.
+    /// @return Signer of 0x transaction if entry point is `executeTransaction`.
+    ///         `msg.sender` if entry point is any other function.
+    function getCurrentContextAddress()
+        internal
+        view
+        returns (address)
+    {
+        address contextAddress = currentContextAddress == address(0) ? msg.sender : currentContextAddress;
+        return contextAddress;
+    }
+}