Contract 0x8b84CAE3ec8E9481cCBb41f92CBDb8422bBadf4F

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7Match Orders422068892022-11-29 16:34:386 days 4 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00141067
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81dfMatch Orders422067812022-11-29 16:34:086 days 4 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00141675
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84dMatch Orders422066732022-11-29 16:33:396 days 4 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00140882
0xe6af2204b7319608483c180db9bc28d01d481678324ac0055ee23e2ccf446a86Match Orders422063962022-11-29 16:32:196 days 4 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00144939
0xa80804e3eb06e20e59448c4b85822eb2af9dc6a9e2c38d3eb2dd4953fd619382Match Orders422027022022-11-29 16:15:276 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00120195
0xe76c5da2d7cf8f139280a87b32da973401c88b18ec06f3fb98d71c661af80c0dMatch Orders421996642022-11-29 16:01:516 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00120411
0x0cda38a6d94b187b0ef82451d34a6bb46179aeb7f4fd3df75f8544ad855465f1Match Orders421993272022-11-29 16:00:166 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00121236
0x736ae42226a74b946ffd0be1c455b7851d91c23a238f6e03b3009839d4ff9271Match Orders421982622022-11-29 15:55:266 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00119137
0xf59c0e61c4aced4061577c668748b2501a95de08f65c18019ac0657e3dd52514Match Orders421980612022-11-29 15:54:306 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00120643
0xf44e595c6eb78ed1f63c767d9e54462b9b3ad23c61ac9237a08ba5a9c3cce6a4Match Orders421979252022-11-29 15:53:536 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00117461
0xb78a270997921ec7f1e79323ce16557f1d0cfbd26869fbaa29c4fc1665efea26Match Orders421977762022-11-29 15:53:146 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00118132
0xcaa0ffa809e5e9d70080b2bc892d5fbfb53f3faf9bc4706a222093f2f41cbb56Match Orders421976012022-11-29 15:52:276 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00118442
0xe0ae4305f2202338210fcb9de081f03c225ed8770d3dce2182246715201b3d4eMatch Orders421974202022-11-29 15:51:386 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00117722
0x0f4370aea129403e30f06760ef04cb5f361efec2dc6543d9332fd2cafd3bd228Match Orders421950982022-11-29 15:41:236 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00111875
0x8dcc073fa17749081d1e168046a00fc20e7d0796e21593cfb86a0e055f7aa372Match Orders421949672022-11-29 15:40:496 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00112446
0xb73efa5794fb8adef545b2e32d37aefde7be596cf4052f8de66a1f1bd7e76230Match Orders421948422022-11-29 15:40:166 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00111492
0x7115f7bbc9dd61a8390a89c089492d9566adae2c881a744157879d868d94e507Match Orders421946942022-11-29 15:39:366 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.0011283
0x4d75448315241d62906d3c0f88294b519143c7f5d8c1ae7c7417b94cea6bce84Match Orders421945172022-11-29 15:38:476 days 5 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00114863
0x0387ffc64b3ea7b1d1e98cee5ec8b570ef137fe0d46a57f9420c4893d55fa678Match Orders421917382022-11-29 15:26:426 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00111823
0x3d6697b36e409e3f78490b2b6a235cb463303ea326d6d629676ffa4444bdabc0Match Orders421915232022-11-29 15:25:436 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.001125
0x7dffe27c3b6f5157ff08a1c5e2c44599386dac8c5f08744c82415c1ac5ff0f86Match Orders421901282022-11-29 15:19:396 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00115823
0x21bcecdc1994366a4e8ea40945590407b407fb41473e15222613fafefb0f16ecMatch Orders421900052022-11-29 15:19:076 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00118598
0xc8ba1e8e540e30216e33dc5f315bd70845e916544ec61724e9c7b87dfd0af6ccMatch Orders421894212022-11-29 15:16:426 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00112995
0x1acdfe872cf738e9329934aeb16a22d333a077895269f5a1dd3373fbbcdf5ab3Match Orders421867172022-11-29 15:04:506 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00123411
0xeca0583c307b2e3b6e65c7308324dc0f3de6b5d0319e9dd424a9599d809a4a25Match Orders421853782022-11-29 14:59:006 days 6 hrs ago0x1375fa71dfd8e2bed4bf6072a4a550618ceff91c IN  0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0 ETH0.00128288
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0x39c08ce8cba26b50ce24b08cd05292c637eb53611bd64484eacdbbf028b06ff7422068892022-11-29 16:34:386 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f ZigZag: ZZ Token0 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0xcaab6215e74ca6a297f3dc77acf104c62bf1569a22b955349ab02948735b81df422067812022-11-29 16:34:086 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0xcd0d354cf33364a164bcc3f69bd803b77415dbb53dbaa71b0a9b76332528e84d422066732022-11-29 16:33:396 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f0x00000000000000000000000000000000000000010 ETH
0xe6af2204b7319608483c180db9bc28d01d481678324ac0055ee23e2ccf446a86422063962022-11-29 16:32:196 days 4 hrs ago 0x8b84cae3ec8e9481ccbb41f92cbdb8422bbadf4f 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ZigZagExchange

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 12 : ZigZagExchange.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './LibOrder.sol';
import './LibFillResults.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {EIP712} from '@openzeppelin/contracts/utils/cryptography/EIP712.sol';
import {SignatureChecker} from '@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol';

//import "hardhat/console.sol";

contract ZigZagExchange is EIP712 {
  event Swap(
    address maker,
    address taker,
    address makerSellToken,
    address takerSellToken,
    uint256 makerSellAmount,
    uint256 takerSellAmount,
    uint256 makerVolumeFee,
    uint256 takerVolumeFee
  );

  using LibOrder for LibOrder.Order;

  mapping(bytes32 => uint256) public filled;

  mapping(bytes32 => bool) public cancelled;

  // fees
  address FEE_ADDRESS;
  uint256 maker_fee_numerator = 0;
  uint256 maker_fee_denominator = 10000;
  uint256 taker_fee_numerator = 5;
  uint256 taker_fee_denominator = 10000;

  // initialize fee address
  constructor(
    string memory name,
    string memory version,
    address fee_address
  ) EIP712(name, version) {
    FEE_ADDRESS = fee_address;
  }

  function cancelOrder(LibOrder.Order memory order) public {
    require(msg.sender == order.user, 'only user may cancel order');

    bytes32 orderHash = order.getOrderHash();

    cancelled[orderHash] = true;
  }

  function matchOrders(
    LibOrder.Order memory makerOrder,
    LibOrder.Order memory takerOrder,
    bytes memory makerSignature,
    bytes memory takerSignature
  )
    public
    returns (LibFillResults.MatchedFillResults memory matchedFillResults)
  {
    // check that tokens address match
    require(takerOrder.sellToken == makerOrder.buyToken, 'mismatched tokens');
    require(takerOrder.buyToken == makerOrder.sellToken, 'mismatched tokens');

    // no self-swap
    require(takerOrder.user != makerOrder.user, 'self swap not allowed');

    LibOrder.OrderInfo memory makerOrderInfo = getOrderInfo(makerOrder);
    LibOrder.OrderInfo memory takerOrderInfo = getOrderInfo(takerOrder);

    //validate signature
    require(
      _isValidSignatureHash(
        takerOrder.user,
        takerOrderInfo.orderHash,
        takerSignature
      ),
      'invalid taker signature'
    );
    require(
      _isValidSignatureHash(
        makerOrder.user,
        makerOrderInfo.orderHash,
        makerSignature
      ),
      'invalid maker signature'
    );

    // Make sure there is a profitable spread.
    // There is a profitable spread iff the cost per unit bought (OrderA.SellAmount/OrderA.BuyAmount) for each order is greater
    // than the profit per unit sold of the matched order (OrderB.BuyAmount/OrderB.SellAmount).
    // This is satisfied by the equations below:
    // <makerOrder.sellAmount> / <makerOrder.buyAmount> >= <takerOrder.buyAmount> / <takerOrder.sellAmount>
    // AND
    // <takerOrder.sellAmount> / <takerOrder.buyAmount> >= <makerOrder.buyAmount> / <makerOrder.sellAmount>
    // These equations can be combined to get the following:
    require(
      makerOrder.sellAmount * takerOrder.sellAmount >=
        makerOrder.buyAmount * takerOrder.buyAmount,
      'not profitable spread'
    );

    matchedFillResults = LibFillResults.calculateMatchedFillResults(
      makerOrder,
      takerOrder,
      makerOrderInfo.orderBuyFilledAmount,
      takerOrderInfo.orderBuyFilledAmount,
      maker_fee_numerator,
      maker_fee_denominator,
      taker_fee_numerator,
      taker_fee_denominator
    );

    _updateFilledState(
      makerOrderInfo.orderHash,
      matchedFillResults.takerSellFilledAmount
    );

    _updateFilledState(
      takerOrderInfo.orderHash,
      matchedFillResults.makerSellFilledAmount
    );

    _settleMatchedOrders(makerOrder, takerOrder, matchedFillResults);
  }

  function _settleMatchedOrders(
    LibOrder.Order memory makerOrder,
    LibOrder.Order memory takerOrder,
    LibFillResults.MatchedFillResults memory matchedFillResults
  ) internal {
    require(
      IERC20(takerOrder.sellToken).balanceOf(takerOrder.user) >=
        matchedFillResults.takerSellFilledAmount,
      'taker order not enough balance'
    );
    require(
      IERC20(makerOrder.sellToken).balanceOf(makerOrder.user) >=
        matchedFillResults.makerSellFilledAmount,
      'maker order not enough balance'
    );

    // Right maker asset -> maker maker
    IERC20(takerOrder.sellToken).transferFrom(
      takerOrder.user,
      makerOrder.user,
      matchedFillResults.takerSellFilledAmount
    );

    // Left maker asset -> taker maker
    IERC20(makerOrder.sellToken).transferFrom(
      makerOrder.user,
      takerOrder.user,
      matchedFillResults.makerSellFilledAmount
    );

    /* Fees Paid */
    // Taker fee + gas fee -> fee recipient
    if (matchedFillResults.takerFeePaid > 0) {
      require(
        IERC20(takerOrder.sellToken).balanceOf(takerOrder.user) >=
          matchedFillResults.takerFeePaid,
        'taker order not enough balance for fee'
      );
      IERC20(takerOrder.sellToken).transferFrom(
        takerOrder.user,
        FEE_ADDRESS,
        matchedFillResults.takerFeePaid
      );
    }

    // Maker fee -> fee recipient
    if (matchedFillResults.makerFeePaid > 0) {
      require(
        IERC20(makerOrder.sellToken).balanceOf(makerOrder.user) >=
          matchedFillResults.makerFeePaid,
        'maker order not enough balance for fee'
      );
      IERC20(makerOrder.sellToken).transferFrom(
        makerOrder.user,
        FEE_ADDRESS,
        matchedFillResults.makerFeePaid
      );
    }

    emit Swap(
      makerOrder.user,
      takerOrder.user,
      makerOrder.sellToken,
      takerOrder.sellToken,
      matchedFillResults.makerSellFilledAmount,
      matchedFillResults.takerSellFilledAmount,
      matchedFillResults.makerFeePaid,
      matchedFillResults.takerFeePaid
    );
  }

  function _updateFilledState(bytes32 orderHash, uint256 orderBuyFilledAmount)
    internal
  {
    filled[orderHash] += orderBuyFilledAmount;
  }

  function getOrderInfo(LibOrder.Order memory order)
    public
    view
    returns (LibOrder.OrderInfo memory orderInfo)
  {
    (
      orderInfo.orderHash,
      orderInfo.orderBuyFilledAmount
    ) = _getOrderHashAndFilledAmount(order);

    require(
      orderInfo.orderBuyFilledAmount < order.buyAmount,
      'order is filled'
    );
    require(block.timestamp <= order.expirationTimeSeconds, 'order expired');
    require(!cancelled[orderInfo.orderHash], 'order canceled');

    orderInfo.orderStatus = LibOrder.OrderStatus.FILLABLE;
  }

  function _getOrderHashAndFilledAmount(LibOrder.Order memory order)
    internal
    view
    returns (bytes32 orderHash, uint256 orderBuyFilledAmount)
  {
    orderHash = order.getOrderHash();
    orderBuyFilledAmount = filled[orderHash];
  }

  function isValidSignature(LibOrder.Order memory order, bytes memory signature)
    public
    view
    returns (bool)
  {
    bytes32 orderHash = order.getOrderHash();

    return _isValidSignatureHash(order.user, orderHash, signature);
  }

  function _isValidSignatureHash(
    address user,
    bytes32 orderHash,
    bytes memory signature
  ) private view returns (bool) {
    bytes32 digest = _hashTypedDataV4(orderHash);

    return SignatureChecker.isValidSignatureNow(user, digest, signature);
  }

  function setFees(
    uint256 _taker_fee_numerator,
    uint256 _taker_fee_denominator,
    uint256 _maker_fee_numerator,
    uint256 _maker_fee_denominator
  ) public {
    require(msg.sender == FEE_ADDRESS, 'only fee address may update fees');

    taker_fee_numerator = _taker_fee_numerator;
    taker_fee_denominator = _taker_fee_denominator;
    maker_fee_numerator = _maker_fee_numerator;
    maker_fee_denominator = _maker_fee_denominator;
  }
}

File 2 of 12 : LibOrder.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library LibOrder {
  bytes32 internal constant _EIP712_ORDER_SCHEMA_HASH =
    0x68d868c8698fc31da3a36bb7a184a4af099797794701bae97bea3de7ebe6e399;
  //keccak256("Order(address user,address sellToken,address buyToken,uint256 sellAmount,uint256 buyAmount,uint256 expirationTimeSeconds)")

  enum OrderStatus {
    INVALID, // Default value
    INVALID_MAKER_ASSET_AMOUNT, // Order does not have a valid maker asset amount
    INVALID_TAKER_ASSET_AMOUNT, // Order does not have a valid taker asset amount
    FILLABLE, // Order is fillable
    EXPIRED, // Order has already expired
    FULLY_FILLED, // Order is fully filled
    CANCELLED // Order has been cancelled
  }

  struct Order {
    address user; //address of the Order Creator making the sale
    address sellToken; // address of the Token the Order Creator wants to sell
    address buyToken; // address of the Token the Order Creator wants to receive in return
    uint256 sellAmount; // amount of Token that the Order Creator wants to sell
    uint256 buyAmount; // amount of Token that the Order Creator wants to receive in return
    uint256 expirationTimeSeconds; //time after which the order is no longer valid
  }

  struct OrderInfo {
    OrderStatus orderStatus; // Status that describes order's validity and fillability.
    bytes32 orderHash; // EIP712 typed data hash of the order (see LibOrder.getTypedDataHash).
    uint256 orderBuyFilledAmount; // Amount of order that has already been filled.
  }

  // https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct
  function getOrderHash(Order memory order) internal pure returns (bytes32 orderHash) {
    orderHash = keccak256(
      abi.encode(
        _EIP712_ORDER_SCHEMA_HASH,
        order.user,
        order.sellToken,
        order.buyToken,
        order.sellAmount,
        order.buyAmount,
        order.expirationTimeSeconds
      )
    );
  }
}

File 3 of 12 : LibFillResults.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './LibOrder.sol';
import './LibMath.sol';

library LibFillResults {
  struct MatchedFillResults {
    uint256 makerSellFilledAmount; // The amount sold by the maker in the maker sell token
    uint256 takerSellFilledAmount; // The amount received by the taker in the taker sell token
    uint256 makerFeePaid; // The fee paid by the maker in the maker sell token
    uint256 takerFeePaid; // The fee paid by the taker in the taker sell token
  }

  function calculateMatchedFillResults(
    LibOrder.Order memory makerOrder,
    LibOrder.Order memory takerOrder,
    uint256 makerOrderBuyFilledAmount,
    uint256 takerOrderBuyFilledAmount,
    uint256 maker_fee_numerator,
    uint256 maker_fee_denominator,
    uint256 taker_fee_numerator,
    uint256 taker_fee_denominator
  ) internal pure returns (MatchedFillResults memory matchedFillResults) {
    uint256 makerBuyAmountRemaining = makerOrder.buyAmount -
      makerOrderBuyFilledAmount;
    uint256 makerSellAmountRemaining = LibMath.safeGetPartialAmountFloor(
      makerOrder.sellAmount,
      makerOrder.buyAmount,
      makerBuyAmountRemaining
    );

    uint256 takerBuyAmountRemaining = takerOrder.buyAmount -
      takerOrderBuyFilledAmount;
    uint256 takerSellAmountRemaining = LibMath.safeGetPartialAmountFloor(
      takerOrder.sellAmount,
      takerOrder.buyAmount,
      takerBuyAmountRemaining
    );

    matchedFillResults = _calculateMatchedFillResultsWithMaximalFill(
      makerOrder,
      makerSellAmountRemaining,
      makerBuyAmountRemaining,
      takerSellAmountRemaining
    );

    // Compute volume fees
    matchedFillResults.makerFeePaid =
      (matchedFillResults.makerSellFilledAmount * maker_fee_numerator) /
      maker_fee_denominator;
    matchedFillResults.takerFeePaid =
      (matchedFillResults.takerSellFilledAmount * taker_fee_numerator) /
      taker_fee_denominator;
  }

  function _calculateMatchedFillResultsWithMaximalFill(
    LibOrder.Order memory makerOrder,
    uint256 makerSellAmountRemaining,
    uint256 makerBuyAmountRemaining,
    uint256 takerSellAmountRemaining
  ) private pure returns (MatchedFillResults memory matchedFillResults) {
    // Calculate the maximum fill results for the maker and taker assets. At least one of the orders will be fully filled.
    //
    // The maximum that the maker maker can possibly buy is the amount that the taker order can sell.
    // The maximum that the taker maker can possibly buy is the amount that the maker order can sell.
    //
    // If the maker order is fully filled, profit will be paid out in the maker maker asset. If the taker order is fully filled,
    // the profit will be out in the taker maker asset.
    //
    // There are three cases to consider:
    // Case 1.
    //   If the maker can buy more or the same as the taker can sell, then the taker order is fully filled, but at the price of the maker order.
    // Case 2.
    //   If the taker can buy more or the same as the maker can sell, then the maker order is fully filled, at the price of the maker order.
    // Case 3.
    //   Both orders can be filled fully so we can default to case 2

    if (makerBuyAmountRemaining >= takerSellAmountRemaining) {
      matchedFillResults.makerSellFilledAmount = LibMath
        .safeGetPartialAmountFloor(
          makerOrder.sellAmount,
          makerOrder.buyAmount,
          takerSellAmountRemaining
        );
      matchedFillResults.takerSellFilledAmount = takerSellAmountRemaining;
    } else {
      matchedFillResults.makerSellFilledAmount = makerSellAmountRemaining;
      matchedFillResults.takerSellFilledAmount = makerBuyAmountRemaining;
    }

    return matchedFillResults;
  }
}

File 4 of 12 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

File 5 of 12 : EIP712.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

File 6 of 12 : SignatureChecker.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../Address.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        if (error == ECDSA.RecoverError.NoError && recovered == signer) {
            return true;
        }

        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length == 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

File 7 of 12 : LibMath.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library LibMath {
  function safeGetPartialAmountFloor(
    uint256 numerator,
    uint256 denominator,
    uint256 target
  ) internal pure returns (uint256 partialAmount) {
    require(
      !isRoundingErrorFloor(numerator, denominator, target),
      'floor rounding error >= 0.1%'
    );
    partialAmount = (numerator * target) / denominator;
    return partialAmount;
  }

  function safeGetPartialAmountCeil(
    uint256 numerator,
    uint256 denominator,
    uint256 target
  ) internal pure returns (uint256 partialAmount) {
    require(
      !isRoundingErrorCeil(numerator, denominator, target),
      'ceil rounding error >= 0.1%'
    );

    // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
    //       ceil(a / b) = floor((a + b - 1) / b)
    // To implement `ceil(a / b)` using safeDiv.
    partialAmount = (numerator * (target + (denominator - 1))) / denominator;

    return partialAmount;
  }

  function isRoundingErrorFloor(
    uint256 numerator,
    uint256 denominator,
    uint256 target
  ) internal pure returns (bool isError) {
    require(denominator != 0, 'error denominator is zero');
    if (target == 0 || numerator == 0) {
      return false;
    }
    uint256 remainder = mulmod(target, numerator, denominator);

    isError = remainder * 1000 >= numerator * target;
    return isError;
  }

  function isRoundingErrorCeil(
    uint256 numerator,
    uint256 denominator,
    uint256 target
  ) internal pure returns (bool isError) {
    require(denominator != 0, 'error denominator is zero');

    // See the comments in `isRoundingError`.
    if (target == 0 || numerator == 0) {
      // When either is zero, the ideal value and rounded value are zero
      // and there is no rounding error. (Although the relative error
      // is undefined.)
      return false;
    }
    // Compute remainder as before
    uint256 remainder = mulmod(target, numerator, denominator);
    remainder = (denominator - remainder) % denominator;
    isError = remainder * 1000 >= numerator * target;
    return isError;
  }
}

File 8 of 12 : ECDSA.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

File 9 of 12 : Strings.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

File 10 of 12 : Math.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

File 11 of 12 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.2) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 12 of 12 : IERC1271.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

Settings
{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"address","name":"fee_address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"maker","type":"address"},{"indexed":false,"internalType":"address","name":"taker","type":"address"},{"indexed":false,"internalType":"address","name":"makerSellToken","type":"address"},{"indexed":false,"internalType":"address","name":"takerSellToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"makerSellAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerSellAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"makerVolumeFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerVolumeFee","type":"uint256"}],"name":"Swap","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"sellToken","type":"address"},{"internalType":"address","name":"buyToken","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"},{"internalType":"uint256","name":"buyAmount","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"}],"internalType":"struct LibOrder.Order","name":"order","type":"tuple"}],"name":"cancelOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"cancelled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"filled","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"sellToken","type":"address"},{"internalType":"address","name":"buyToken","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"},{"internalType":"uint256","name":"buyAmount","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"}],"internalType":"struct LibOrder.Order","name":"order","type":"tuple"}],"name":"getOrderInfo","outputs":[{"components":[{"internalType":"enum LibOrder.OrderStatus","name":"orderStatus","type":"uint8"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"internalType":"uint256","name":"orderBuyFilledAmount","type":"uint256"}],"internalType":"struct LibOrder.OrderInfo","name":"orderInfo","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"sellToken","type":"address"},{"internalType":"address","name":"buyToken","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"},{"internalType":"uint256","name":"buyAmount","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"}],"internalType":"struct LibOrder.Order","name":"order","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"sellToken","type":"address"},{"internalType":"address","name":"buyToken","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"},{"internalType":"uint256","name":"buyAmount","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"}],"internalType":"struct LibOrder.Order","name":"makerOrder","type":"tuple"},{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"sellToken","type":"address"},{"internalType":"address","name":"buyToken","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"},{"internalType":"uint256","name":"buyAmount","type":"uint256"},{"internalType":"uint256","name":"expirationTimeSeconds","type":"uint256"}],"internalType":"struct LibOrder.Order","name":"takerOrder","type":"tuple"},{"internalType":"bytes","name":"makerSignature","type":"bytes"},{"internalType":"bytes","name":"takerSignature","type":"bytes"}],"name":"matchOrders","outputs":[{"components":[{"internalType":"uint256","name":"makerSellFilledAmount","type":"uint256"},{"internalType":"uint256","name":"takerSellFilledAmount","type":"uint256"},{"internalType":"uint256","name":"makerFeePaid","type":"uint256"},{"internalType":"uint256","name":"takerFeePaid","type":"uint256"}],"internalType":"struct LibFillResults.MatchedFillResults","name":"matchedFillResults","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_taker_fee_numerator","type":"uint256"},{"internalType":"uint256","name":"_taker_fee_denominator","type":"uint256"},{"internalType":"uint256","name":"_maker_fee_numerator","type":"uint256"},{"internalType":"uint256","name":"_maker_fee_denominator","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000f4bba1e2a5024a2754225b981e9a0db7d2c33ee900000000000000000000000000000000000000000000000000000000000000065a69675a616700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003322e300000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): ZigZag
Arg [1] : version (string): 2.0
Arg [2] : fee_address (address): 0xf4bba1e2a5024a2754225b981e9a0db7d2c33ee9

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 000000000000000000000000f4bba1e2a5024a2754225b981e9a0db7d2c33ee9
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [4] : 5a69675a61670000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 322e300000000000000000000000000000000000000000000000000000000000


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.