Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract SafeMath
•    - function safeMul(uint256 a, uint256 b ...
•    - function safeDiv(uint256 a, uint256 b ...
•    - function safeSub(uint256 a, uint256 b ...
•    - function safeAdd(uint256 a, uint256 b ...
•    - function max64(uint64 a, uint64 b)
•    - function min64(uint64 a, uint64 b)
•    - function max256(uint256 a, uint256 b)
•    - function min256(uint256 a, uint256 b)
•  contract LibFillResults is
•    - function addFillResults(FillResults m ...
•  contract LibEIP712
•    - function hashEIP712Message(bytes32 ha ...
•  contract LibOrder is
•    - function getOrderHash(Order memory or ...
•    - function hashOrder(Order memory order ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•  contract IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
•  contract IExchange
•    - function fillOrKillOrder(
•    - function fillOrderNoThrow(
•    - function batchFillOrders(
•    - function batchFillOrKillOrders(
•    - function batchFillOrdersNoThrow(
•    - function marketSellOrders(
•    - function marketSellOrdersNoThrow(
•    - function marketBuyOrders(
•    - function marketBuyOrdersNoThrow(
•    - function batchCancelOrders(LibOrder.O ...
•    - function getOrdersInfo(LibOrder.Order ...
•  contract IEtherToken is IERC20
•    - function deposit()
•    - function withdraw(uint256 _amount)
•    - function withdrawTo(address _to, uint ...
• library LibBytesRichErrors
•    - function InvalidByteOperationError(
• library LibRichErrors
•    - function StandardError(
•    - function rrevert(bytes memory errorDa ...
• library LibBytes
•    - function rawAddress(bytes memory inpu ...
•    - function contentAddress(bytes memory ...
•    - function memCopy(
•    - function slice(
•    - function sliceDestructive(
•    - function popLastByte(bytes memory b)
•    - function equals(
•    - function readAddress(
•    - function writeAddress(
•    - function readBytes32(
•    - function writeBytes32(
•    - function readUint256(
•    - function writeUint256(
•    - function readBytes4(
•    - function writeLength(bytes memory b, ...
•  contract Forwarder is LibOrder *
•    - function fillOrders(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-11-22
*/

pragma solidity 0.5.11;
pragma experimental ABIEncoderV2;


contract SafeMath {

    function safeMul(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(
            c / a == b,
            "UINT256_OVERFLOW"
        );
        return c;
    }

    function safeDiv(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        uint256 c = a / b;
        return c;
    }

    function safeSub(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        require(
            b <= a,
            "UINT256_UNDERFLOW"
        );
        return a - b;
    }

    function safeAdd(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        uint256 c = a + b;
        require(
            c >= a,
            "UINT256_OVERFLOW"
        );
        return c;
    }

    function max64(uint64 a, uint64 b)
        internal
        pure
        returns (uint256)
    {
        return a >= b ? a : b;
    }

    function min64(uint64 a, uint64 b)
        internal
        pure
        returns (uint256)
    {
        return a < b ? a : b;
    }

    function max256(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        return a >= b ? a : b;
    }

    function min256(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        return a < b ? a : b;
    }
}

contract LibFillResults is
    SafeMath
{
    struct FillResults {
        uint256 makerAssetFilledAmount;  
        uint256 takerAssetFilledAmount;  
        uint256 makerFeePaid;            
        uint256 takerFeePaid;            
    }

    struct MatchedFillResults {
        FillResults left;                    
        FillResults right;                   
        uint256 leftMakerAssetSpreadAmount;  
    }

    
    
    
    
    function addFillResults(FillResults memory totalFillResults, FillResults memory singleFillResults)
        internal
        pure
    {
        totalFillResults.makerAssetFilledAmount = safeAdd(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount);
        totalFillResults.takerAssetFilledAmount = safeAdd(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount);
        totalFillResults.makerFeePaid = safeAdd(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid);
        totalFillResults.takerFeePaid = safeAdd(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid);
    }
}

contract LibEIP712 {

    
    string constant internal EIP191_HEADER = "\x19\x01";

    
    string constant internal EIP712_DOMAIN_NAME = "0x Protocol";

    
    string constant internal EIP712_DOMAIN_VERSION = "2";

    
    bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
        "EIP712Domain(",
        "string name,",
        "string version,",
        "address verifyingContract",
        ")"
    ));

    
    
    bytes32 public EIP712_DOMAIN_HASH;

    constructor ()
        public
    {
        EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
            keccak256(bytes(EIP712_DOMAIN_NAME)),
            keccak256(bytes(EIP712_DOMAIN_VERSION)),
            uint256(address(this))
        ));
    }

    
    
    
    function hashEIP712Message(bytes32 hashStruct)
        internal
        view
        returns (bytes32 result)
    {
        bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;

        
        
        
        
        
        

        assembly {
            
            let memPtr := mload(64)

            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)  
            mstore(add(memPtr, 2), eip712DomainHash)                                            
            mstore(add(memPtr, 34), hashStruct)                                                 

            
            result := keccak256(memPtr, 66)
        }
        return result;
    }
}

contract LibOrder is
    LibEIP712
{
    
    bytes32 constant internal EIP712_ORDER_SCHEMA_HASH = keccak256(abi.encodePacked(
        "Order(",
        "address makerAddress,",
        "address takerAddress,",
        "address feeRecipientAddress,",
        "address senderAddress,",
        "uint256 makerAssetAmount,",
        "uint256 takerAssetAmount,",
        "uint256 makerFee,",
        "uint256 takerFee,",
        "uint256 expirationTimeSeconds,",
        "uint256 salt,",
        "bytes makerAssetData,",
        "bytes takerAssetData",
        ")"
    ));

    
    
    enum OrderStatus {
        INVALID,                     
        INVALID_MAKER_ASSET_AMOUNT,  
        INVALID_TAKER_ASSET_AMOUNT,  
        FILLABLE,                    
        EXPIRED,                     
        FULLY_FILLED,                
        CANCELLED                    
    }

    
    struct Order {
        address makerAddress;           
        address takerAddress;           
        address feeRecipientAddress;    
        address senderAddress;          
        uint256 makerAssetAmount;       
        uint256 takerAssetAmount;       
        uint256 makerFee;               
        uint256 takerFee;               
        uint256 expirationTimeSeconds;  
        uint256 salt;                   
        bytes makerAssetData;           
        bytes takerAssetData;           
    }
    

    struct OrderInfo {
        uint8 orderStatus;                    
        bytes32 orderHash;                    
        uint256 orderTakerAssetFilledAmount;  
    }

    
    
    
    function getOrderHash(Order memory order)
        internal
        view
        returns (bytes32 orderHash)
    {
        orderHash = hashEIP712Message(hashOrder(order));
        return orderHash;
    }

    
    
    
    function hashOrder(Order memory order)
        internal
        pure
        returns (bytes32 result)
    {
        bytes32 schemaHash = EIP712_ORDER_SCHEMA_HASH;
        bytes32 makerAssetDataHash = keccak256(order.makerAssetData);
        bytes32 takerAssetDataHash = keccak256(order.takerAssetData);

        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        

        assembly {
            
            let pos1 := sub(order, 32)
            let pos2 := add(order, 320)
            let pos3 := add(order, 352)

            
            let temp1 := mload(pos1)
            let temp2 := mload(pos2)
            let temp3 := mload(pos3)
            
            
            mstore(pos1, schemaHash)
            mstore(pos2, makerAssetDataHash)
            mstore(pos3, takerAssetDataHash)
            result := keccak256(pos1, 416)
            
            
            mstore(pos1, temp1)
            mstore(pos2, temp2)
            mstore(pos3, temp3)
        }
        return result;
    }
}

interface IERC20 {
    
    function totalSupply() external view returns (uint256);

    
    function balanceOf(address account) external view returns (uint256);

    
    function transfer(address recipient, uint256 amount) external returns (bool);

    
    function allowance(address owner, address spender) external view returns (uint256);

    
    function approve(address spender, uint256 amount) external returns (bool);

    
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    
    event Transfer(address indexed from, address indexed to, uint256 value);

    
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

interface IERC165 {
    
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    
    function balanceOf(address owner) public view returns (uint256 balance);

    
    function ownerOf(uint256 tokenId) public view returns (address owner);

    
    function safeTransferFrom(address from, address to, uint256 tokenId) public;
    
    function transferFrom(address from, address to, uint256 tokenId) public;
    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);


    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

contract IExchange {

    
    
    
    
    function fillOrKillOrder(
        LibOrder.Order memory order,
        uint256 takerAssetFillAmount,
        bytes memory signature
    )
        public
        returns (LibFillResults.FillResults memory fillResults);

    
    
    
    
    
    
    function fillOrderNoThrow(
        LibOrder.Order memory order,
        uint256 takerAssetFillAmount,
        bytes memory signature
    )
        public
        returns (LibFillResults.FillResults memory fillResults);

    
    
    
    
    
    function batchFillOrders(
        LibOrder.Order[] memory orders,
        uint256[] memory takerAssetFillAmounts,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    function batchFillOrKillOrders(
        LibOrder.Order[] memory orders,
        uint256[] memory takerAssetFillAmounts,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    
    function batchFillOrdersNoThrow(
        LibOrder.Order[] memory orders,
        uint256[] memory takerAssetFillAmounts,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    function marketSellOrders(
        LibOrder.Order[] memory orders,
        uint256 takerAssetFillAmount,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    
    function marketSellOrdersNoThrow(
        LibOrder.Order[] memory orders,
        uint256 takerAssetFillAmount,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    function marketBuyOrders(
        LibOrder.Order[] memory orders,
        uint256 makerAssetFillAmount,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    
    
    
    
    function marketBuyOrdersNoThrow(
        LibOrder.Order[] memory orders,
        uint256 makerAssetFillAmount,
        bytes[] memory signatures
    )
        public
        returns (LibFillResults.FillResults memory totalFillResults);

    
    
    function batchCancelOrders(LibOrder.Order[] memory orders)
        public;

    
    
    
    function getOrdersInfo(LibOrder.Order[] memory orders)
        public
        view
        returns (LibOrder.OrderInfo[] memory);
}

contract IEtherToken is IERC20 {
    function deposit() public payable;
    function withdraw(uint256 _amount) public;
    function withdrawTo(address _to, uint256 _amount) public;
}

library LibBytesRichErrors {

    enum InvalidByteOperationErrorCodes {
        FromLessThanOrEqualsToRequired,
        ToLessThanOrEqualsLengthRequired,
        LengthGreaterThanZeroRequired,
        LengthGreaterThanOrEqualsFourRequired,
        LengthGreaterThanOrEqualsTwentyRequired,
        LengthGreaterThanOrEqualsThirtyTwoRequired,
        LengthGreaterThanOrEqualsNestedBytesLengthRequired,
        DestinationLengthGreaterThanOrEqualSourceLengthRequired
    }

    
    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
        0x28006595;

    
    function InvalidByteOperationError(
        InvalidByteOperationErrorCodes errorCode,
        uint256 offset,
        uint256 required
    )
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            INVALID_BYTE_OPERATION_ERROR_SELECTOR,
            errorCode,
            offset,
            required
        );
    }
}

library LibRichErrors {

    
    bytes4 internal constant STANDARD_ERROR_SELECTOR =
        0x08c379a0;

    
    
    
    
    
    
    function StandardError(
        string memory message
    )
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            STANDARD_ERROR_SELECTOR,
            bytes(message)
        );
    }
    

    
    
    function rrevert(bytes memory errorData)
        internal
        pure
    {
        assembly {
            revert(add(errorData, 0x20), mload(errorData))
        }
    }
}

library LibBytes {

    using LibBytes for bytes;

    
    
    
    
    
    function rawAddress(bytes memory input)
        internal
        pure
        returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := input
        }
        return memoryAddress;
    }

    
    
    
    function contentAddress(bytes memory input)
        internal
        pure
        returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := add(input, 32)
        }
        return memoryAddress;
    }

    
    
    
    
    function memCopy(
        uint256 dest,
        uint256 source,
        uint256 length
    )
        internal
        pure
    {
        if (length < 32) {
            
            
            
            assembly {
                let mask := sub(exp(256, sub(32, length)), 1)
                let s := and(mload(source), not(mask))
                let d := and(mload(dest), mask)
                mstore(dest, or(s, d))
            }
        } else {
            
            if (source == dest) {
                return;
            }

            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            if (source > dest) {
                assembly {
                    
                    
                    
                    
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    
                    
                    
                    
                    let last := mload(sEnd)

                    
                    
                    
                    
                    for {} lt(source, sEnd) {} {
                        mstore(dest, mload(source))
                        source := add(source, 32)
                        dest := add(dest, 32)
                    }

                    
                    mstore(dEnd, last)
                }
            } else {
                assembly {
                    
                    
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    
                    
                    
                    
                    let first := mload(source)

                    
                    
                    
                    
                    
                    
                    
                    
                    for {} slt(dest, dEnd) {} {
                        mstore(dEnd, mload(sEnd))
                        sEnd := sub(sEnd, 32)
                        dEnd := sub(dEnd, 32)
                    }

                    
                    mstore(dest, first)
                }
            }
        }
    }

    
    
    
    
    
    function slice(
        bytes memory b,
        uint256 from,
        uint256 to
    )
        internal
        pure
        returns (bytes memory result)
    {
        
        
        if (from > to) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                from,
                to
            ));
        }
        if (to > b.length) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                to,
                b.length
            ));
        }

        
        result = new bytes(to - from);
        memCopy(
            result.contentAddress(),
            b.contentAddress() + from,
            result.length
        );
        return result;
    }

    
    
    
    
    
    
    function sliceDestructive(
        bytes memory b,
        uint256 from,
        uint256 to
    )
        internal
        pure
        returns (bytes memory result)
    {
        
        
        if (from > to) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                from,
                to
            ));
        }
        if (to > b.length) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                to,
                b.length
            ));
        }

        
        assembly {
            result := add(b, from)
            mstore(result, sub(to, from))
        }
        return result;
    }

    
    
    
    function popLastByte(bytes memory b)
        internal
        pure
        returns (bytes1 result)
    {
        if (b.length == 0) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
                b.length,
                0
            ));
        }

        
        result = b[b.length - 1];

        assembly {
            
            let newLen := sub(mload(b), 1)
            mstore(b, newLen)
        }
        return result;
    }

    
    
    
    
    function equals(
        bytes memory lhs,
        bytes memory rhs
    )
        internal
        pure
        returns (bool equal)
    {
        
        
        
        return lhs.length == rhs.length && keccak256(lhs) == keccak256(rhs);
    }

    
    
    
    
    function readAddress(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (address result)
    {
        if (b.length < index + 20) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                b.length,
                index + 20 
            ));
        }

        
        
        
        index += 20;

        
        assembly {
            
            
            
            result := and(mload(add(b, index)), 0xffffffffffffffffffffffffffffffffffffffff)
        }
        return result;
    }

    
    
    
    
    function writeAddress(
        bytes memory b,
        uint256 index,
        address input
    )
        internal
        pure
    {
        if (b.length < index + 20) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                b.length,
                index + 20 
            ));
        }

        
        
        
        index += 20;

        
        assembly {
            
            
            
            

            
            
            
            let neighbors := and(
                mload(add(b, index)),
                0xffffffffffffffffffffffff0000000000000000000000000000000000000000
            )

            
            
            input := and(input, 0xffffffffffffffffffffffffffffffffffffffff)

            
            mstore(add(b, index), xor(input, neighbors))
        }
    }

    
    
    
    
    function readBytes32(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (bytes32 result)
    {
        if (b.length < index + 32) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                b.length,
                index + 32
            ));
        }

        
        index += 32;

        
        assembly {
            result := mload(add(b, index))
        }
        return result;
    }

    
    
    
    
    function writeBytes32(
        bytes memory b,
        uint256 index,
        bytes32 input
    )
        internal
        pure
    {
        if (b.length < index + 32) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                b.length,
                index + 32
            ));
        }

        
        index += 32;

        
        assembly {
            mstore(add(b, index), input)
        }
    }

    
    
    
    
    function readUint256(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (uint256 result)
    {
        result = uint256(readBytes32(b, index));
        return result;
    }

    
    
    
    
    function writeUint256(
        bytes memory b,
        uint256 index,
        uint256 input
    )
        internal
        pure
    {
        writeBytes32(b, index, bytes32(input));
    }

    
    
    
    
    function readBytes4(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (bytes4 result)
    {
        if (b.length < index + 4) {
            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
                b.length,
                index + 4
            ));
        }

        
        index += 32;

        
        assembly {
            result := mload(add(b, index))
            
            
            result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
        }
        return result;
    }

    
    
    
    
    
    function writeLength(bytes memory b, uint256 length)
        internal
        pure
    {
        assembly {
            mstore(b, length)
        }
    }
}

contract Forwarder is LibOrder {

    using LibBytes for bytes;

    address public ZERO_EX_EXCHANGE;
    address public ZERO_EX_TOKEN_PROXY;

    address payable public ETHER_TOKEN;

    constructor(
        address zeroExExchange,
        address zeroExProxy,
        address payable etherToken
    )
        public
    {
        ZERO_EX_EXCHANGE = zeroExExchange;
        ZERO_EX_TOKEN_PROXY = zeroExProxy;
        ETHER_TOKEN = etherToken;

        
        IEtherToken(ETHER_TOKEN).approve(ZERO_EX_TOKEN_PROXY, (2**256)-1);
    }

    function fillOrders(
        LibOrder.Order[] memory orders,
        uint256[] memory takerAssetFillAmounts,
        bytes[] memory signatures
    )
        public
        payable
    {
        
        IEtherToken token = IEtherToken(ETHER_TOKEN);
        IExchange v2Exchange = IExchange(ZERO_EX_EXCHANGE);

        token.deposit.value(msg.value)();

        
        
        for (uint i = 0; i < orders.length; i++) {
            LibFillResults.FillResults memory result = v2Exchange.fillOrderNoThrow(
                orders[i],
                takerAssetFillAmounts[i],
                signatures[i]
            );

            
            (address cardToken, uint256 tokenId) = abi.decode(
                orders[i].makerAssetData.sliceDestructive(
                    4,
                    orders[i].makerAssetData.length
                ),
                (address, uint256)
            );

            
            if (result.takerAssetFilledAmount == takerAssetFillAmounts[i]) {
                IERC721(cardToken).transferFrom(address(this), msg.sender, tokenId);
            }
        }

        uint remainingBalance = token.balanceOf(address(this));
        token.withdraw(remainingBalance);

        
        address(msg.sender).transfer(remainingBalance);

        
        require(
            address(this).balance == 0,
            "Forwarder: must have zero ETH at the end"
        );

    }

    function ()
        external
        payable
    {
        require(
            msg.sender == address(ETHER_TOKEN),
            "Forwarder: will not accept ETH from only ether token address"
        );
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"ETHER_TOKEN","outputs":[{"internalType":"address payable","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ZERO_EX_EXCHANGE","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"address","name":"makerAddress","type":"address"},{"internalType":"address","name":"takerAddress","type":"address"},{"internalType":"address","name":"feeRecipientAddress","type":"address"},{"internalType":"address","name":"senderAddress","type":"address"},{"internalType":"uint256","name":"makerAssetAmount","type":"uint256"},{"internalType":"uint256","name":"takerAssetAmount","type":"uint256"},{"internalType":"uint256","name":"makerFee","type":"uint256"},{"internalType":"uint256","name":"takerFee","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"},{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"bytes","name":"makerAssetData","type":"bytes"},{"internalType":"bytes","name":"takerAssetData","type":"bytes"}],"internalType":"struct LibOrder.Order[]","name":"orders","type":"tuple[]"},{"internalType":"uint256[]","name":"takerAssetFillAmounts","type":"uint256[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"}],"name":"fillOrders","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"ZERO_EX_TOKEN_PROXY","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"EIP712_DOMAIN_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"zeroExExchange","type":"address"},{"internalType":"address","name":"zeroExProxy","type":"address"},{"internalType":"address payable","name":"etherToken","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"}]

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

bzzr://c72be876b35ef141e653b144a306fb98f02cc2917735a4c2e95800ac175883e8