ETH Price: $2,966.81 (-7.68%)
Gas: 10 Gwei

Contract

0x000000000055d65008F1dFf7167f24E70DB431F6
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value

There are no matching entries

Please try again later

Latest 1 internal transaction

Advanced mode:
Parent Txn Hash Block From To Value
171870422023-05-04 11:35:11345 days ago1683200111  Contract Creation0 ETH
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x00000000...D49BA3A0D
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
SeaportProxy

Compiler Version
v0.8.17+commit.8df45f5f

Optimization Enabled:
Yes with 888888 runs

Other Settings:
default evmVersion
File 1 of 8 : SeaportProxy.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {BasicOrder} from "../libraries/OrderStructs.sol";
import {ItemType, OrderType} from "../libraries/seaport/ConsiderationEnums.sol";
import {AdvancedOrder, CriteriaResolver, OrderParameters, OfferItem, ConsiderationItem, FulfillmentComponent, AdditionalRecipient} from "../libraries/seaport/ConsiderationStructs.sol";
import {IProxy} from "../interfaces/IProxy.sol";
import {SeaportInterface} from "../interfaces/SeaportInterface.sol";
import {InvalidOrderLength, TradeExecutionFailed} from "../libraries/SharedErrors.sol";

/**
 * @title SeaportProxy
 * @notice This contract allows NFT sweepers to batch buy NFTs from Seaport
 *         by passing high-level structs + low-level bytes as calldata.
 * @author LooksRare protocol team (👀,💎)
 */
contract SeaportProxy is IProxy {
    SeaportInterface public immutable marketplace;
    address public immutable aggregator;

    /**
     * @param offerFulfillments Contains the order and item index of each offer item
     * @param considerationFulfillments Contains the order and item index of each consideration item
     */
    struct ExtraData {
        FulfillmentComponent[][] offerFulfillments;
        FulfillmentComponent[][] considerationFulfillments;
    }

    /**
     * @param numerator A fraction to attempt to fill
     * @param denominator The total size of the order
     * @param orderType Seaport order type
     * @param zone A zone can cancel the order or restrict who can fulfill the order
     *             depending on the type
     * @param zoneHash An arbitrary 32-byte value that will be supplied to the zone when
     *                 fulfilling restricted orders that the zone can utilize when making
     *                 a determination on whether to authorize the order
     * @param salt An arbitrary source of entropy for the order
     * @param conduitKey A bytes32 value that indicates what conduit, if any, should be
     *                   utilized as a source for token approvals when performing transfers
     * @param recipients Recipients of consideration items
     */
    struct OrderExtraData {
        uint120 numerator;
        uint120 denominator;
        OrderType orderType;
        address zone;
        bytes32 zoneHash;
        uint256 salt;
        bytes32 conduitKey;
        AdditionalRecipient[] recipients;
    }

    /**
     * @param _marketplace Seaport's address
     * @param _aggregator LooksRareAggregator's address
     */
    constructor(address _marketplace, address _aggregator) {
        marketplace = SeaportInterface(_marketplace);
        aggregator = _aggregator;
    }

    /**
     * @notice Execute Seaport NFT sweeps in a single transaction
     * @param orders Orders to be executed by Seaport
     * @param ordersExtraData Extra data for each order
     * @param extraData Extra data for the whole transaction
     * @param recipient The address to receive the purchased NFTs
     * @param isAtomic Flag to enable atomic trades (all or nothing) or partial trades
     */
    function execute(
        BasicOrder[] calldata orders,
        bytes[] calldata ordersExtraData,
        bytes calldata extraData,
        address recipient,
        bool isAtomic
    ) external payable override {
        if (address(this) != aggregator) {
            revert InvalidCaller();
        }

        uint256 ordersLength = orders.length;
        if (ordersLength == 0 || ordersLength != ordersExtraData.length) {
            revert InvalidOrderLength();
        }

        if (isAtomic) {
            _executeAtomicOrders(orders, ordersExtraData, extraData, recipient);
        } else {
            _executeNonAtomicOrders(orders, ordersExtraData, recipient);
        }
    }

    function _executeAtomicOrders(
        BasicOrder[] calldata orders,
        bytes[] calldata ordersExtraData,
        bytes calldata extraData,
        address recipient
    ) private {
        uint256 ordersLength = orders.length;
        AdvancedOrder[] memory advancedOrders = new AdvancedOrder[](ordersLength);
        ExtraData memory extraDataStruct = abi.decode(extraData, (ExtraData));

        uint256 ethValue;

        for (uint256 i; i < ordersLength; ) {
            OrderExtraData memory orderExtraData = abi.decode(ordersExtraData[i], (OrderExtraData));
            advancedOrders[i].parameters = _populateParameters(orders[i], orderExtraData);
            advancedOrders[i].numerator = orderExtraData.numerator;
            advancedOrders[i].denominator = orderExtraData.denominator;
            advancedOrders[i].signature = orders[i].signature;

            if (orders[i].currency == address(0)) {
                ethValue = ethValue + orders[i].price;
            }

            unchecked {
                ++i;
            }
        }

        (bool[] memory availableOrders, ) = marketplace.fulfillAvailableAdvancedOrders{value: ethValue}(
            advancedOrders,
            new CriteriaResolver[](0),
            extraDataStruct.offerFulfillments,
            extraDataStruct.considerationFulfillments,
            bytes32(0),
            recipient,
            ordersLength
        );

        for (uint256 i; i < availableOrders.length; ) {
            if (!availableOrders[i]) {
                revert TradeExecutionFailed();
            }
            unchecked {
                ++i;
            }
        }
    }

    function _executeNonAtomicOrders(
        BasicOrder[] calldata orders,
        bytes[] calldata ordersExtraData,
        address recipient
    ) private {
        for (uint256 i; i < orders.length; ) {
            OrderExtraData memory orderExtraData = abi.decode(ordersExtraData[i], (OrderExtraData));
            AdvancedOrder memory advancedOrder;
            advancedOrder.parameters = _populateParameters(orders[i], orderExtraData);
            advancedOrder.numerator = orderExtraData.numerator;
            advancedOrder.denominator = orderExtraData.denominator;
            advancedOrder.signature = orders[i].signature;

            address currency = orders[i].currency;
            uint256 price = orders[i].price;

            try
                marketplace.fulfillAdvancedOrder{value: currency == address(0) ? price : 0}(
                    advancedOrder,
                    new CriteriaResolver[](0),
                    bytes32(0),
                    recipient
                )
            {} catch {}

            unchecked {
                ++i;
            }
        }
    }

    function _populateParameters(BasicOrder calldata order, OrderExtraData memory orderExtraData)
        private
        pure
        returns (OrderParameters memory parameters)
    {
        uint256 recipientsLength = orderExtraData.recipients.length;

        parameters.offerer = order.signer;
        parameters.zone = orderExtraData.zone;
        parameters.zoneHash = orderExtraData.zoneHash;
        parameters.salt = orderExtraData.salt;
        parameters.conduitKey = orderExtraData.conduitKey;
        parameters.orderType = orderExtraData.orderType;
        parameters.startTime = order.startTime;
        parameters.endTime = order.endTime;
        parameters.totalOriginalConsiderationItems = recipientsLength;

        OfferItem[] memory offer = new OfferItem[](1);
        // Seaport enums start with NATIVE and ERC20 so plus 2
        unchecked {
            offer[0].itemType = ItemType(uint8(order.collectionType) + 2);
        }
        offer[0].token = order.collection;
        offer[0].identifierOrCriteria = order.tokenIds[0];
        uint256 amount = order.amounts[0];
        offer[0].startAmount = amount;
        offer[0].endAmount = amount;
        parameters.offer = offer;

        ConsiderationItem[] memory consideration = new ConsiderationItem[](recipientsLength);
        for (uint256 j; j < recipientsLength; ) {
            AdditionalRecipient memory recipient = orderExtraData.recipients[j];
            // We don't need to assign value to identifierOrCriteria as it is always 0.
            uint256 recipientAmount = recipient.amount;
            consideration[j].startAmount = recipientAmount;
            consideration[j].endAmount = recipientAmount;
            consideration[j].recipient = payable(recipient.recipient);
            consideration[j].itemType = order.currency == address(0) ? ItemType.NATIVE : ItemType.ERC20;
            consideration[j].token = order.currency;

            unchecked {
                ++j;
            }
        }
        parameters.consideration = consideration;
    }
}

File 3 of 8 : OrderStructs.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {CollectionType} from "./OrderEnums.sol";

/**
 * @param signer The order's maker
 * @param collection The address of the ERC721/ERC1155 token to be purchased
 * @param collectionType 0 for ERC721, 1 for ERC1155
 * @param tokenIds The IDs of the tokens to be purchased
 * @param amounts Always 1 when ERC721, can be > 1 if ERC1155
 * @param price The *taker bid* price to pay for the order
 * @param currency The order's currency, address(0) for ETH
 * @param startTime The timestamp when the order starts becoming valid
 * @param endTime The timestamp when the order stops becoming valid
 * @param signature split to v,r,s for LooksRare
 */
struct BasicOrder {
    address signer;
    address collection;
    CollectionType collectionType;
    uint256[] tokenIds;
    uint256[] amounts;
    uint256 price;
    address currency;
    uint256 startTime;
    uint256 endTime;
    bytes signature;
}

/**
 * @param amount ERC20 transfer amount
 * @param currency ERC20 transfer currency
 */
struct TokenTransfer {
    uint256 amount;
    address currency;
}

File 4 of 8 : ConsiderationEnums.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

// prettier-ignore
enum OrderType {
    // 0: no partial fills, anyone can execute
    FULL_OPEN,

    // 1: partial fills supported, anyone can execute
    PARTIAL_OPEN,

    // 2: no partial fills, only offerer or zone can execute
    FULL_RESTRICTED,

    // 3: partial fills supported, only offerer or zone can execute
    PARTIAL_RESTRICTED
}

// prettier-ignore
enum BasicOrderType {
    // 0: no partial fills, anyone can execute
    ETH_TO_ERC721_FULL_OPEN,

    // 1: partial fills supported, anyone can execute
    ETH_TO_ERC721_PARTIAL_OPEN,

    // 2: no partial fills, only offerer or zone can execute
    ETH_TO_ERC721_FULL_RESTRICTED,

    // 3: partial fills supported, only offerer or zone can execute
    ETH_TO_ERC721_PARTIAL_RESTRICTED,

    // 4: no partial fills, anyone can execute
    ETH_TO_ERC1155_FULL_OPEN,

    // 5: partial fills supported, anyone can execute
    ETH_TO_ERC1155_PARTIAL_OPEN,

    // 6: no partial fills, only offerer or zone can execute
    ETH_TO_ERC1155_FULL_RESTRICTED,

    // 7: partial fills supported, only offerer or zone can execute
    ETH_TO_ERC1155_PARTIAL_RESTRICTED,

    // 8: no partial fills, anyone can execute
    ERC20_TO_ERC721_FULL_OPEN,

    // 9: partial fills supported, anyone can execute
    ERC20_TO_ERC721_PARTIAL_OPEN,

    // 10: no partial fills, only offerer or zone can execute
    ERC20_TO_ERC721_FULL_RESTRICTED,

    // 11: partial fills supported, only offerer or zone can execute
    ERC20_TO_ERC721_PARTIAL_RESTRICTED,

    // 12: no partial fills, anyone can execute
    ERC20_TO_ERC1155_FULL_OPEN,

    // 13: partial fills supported, anyone can execute
    ERC20_TO_ERC1155_PARTIAL_OPEN,

    // 14: no partial fills, only offerer or zone can execute
    ERC20_TO_ERC1155_FULL_RESTRICTED,

    // 15: partial fills supported, only offerer or zone can execute
    ERC20_TO_ERC1155_PARTIAL_RESTRICTED,

    // 16: no partial fills, anyone can execute
    ERC721_TO_ERC20_FULL_OPEN,

    // 17: partial fills supported, anyone can execute
    ERC721_TO_ERC20_PARTIAL_OPEN,

    // 18: no partial fills, only offerer or zone can execute
    ERC721_TO_ERC20_FULL_RESTRICTED,

    // 19: partial fills supported, only offerer or zone can execute
    ERC721_TO_ERC20_PARTIAL_RESTRICTED,

    // 20: no partial fills, anyone can execute
    ERC1155_TO_ERC20_FULL_OPEN,

    // 21: partial fills supported, anyone can execute
    ERC1155_TO_ERC20_PARTIAL_OPEN,

    // 22: no partial fills, only offerer or zone can execute
    ERC1155_TO_ERC20_FULL_RESTRICTED,

    // 23: partial fills supported, only offerer or zone can execute
    ERC1155_TO_ERC20_PARTIAL_RESTRICTED
}

// prettier-ignore
enum BasicOrderRouteType {
    // 0: provide Ether (or other native token) to receive offered ERC721 item.
    ETH_TO_ERC721,

    // 1: provide Ether (or other native token) to receive offered ERC1155 item.
    ETH_TO_ERC1155,

    // 2: provide ERC20 item to receive offered ERC721 item.
    ERC20_TO_ERC721,

    // 3: provide ERC20 item to receive offered ERC1155 item.
    ERC20_TO_ERC1155,

    // 4: provide ERC721 item to receive offered ERC20 item.
    ERC721_TO_ERC20,

    // 5: provide ERC1155 item to receive offered ERC20 item.
    ERC1155_TO_ERC20
}

// prettier-ignore
enum ItemType {
    // 0: ETH on mainnet, MATIC on polygon, etc.
    NATIVE,

    // 1: ERC20 items (ERC777 and ERC20 analogues could also technically work)
    ERC20,

    // 2: ERC721 items
    ERC721,

    // 3: ERC1155 items
    ERC1155,

    // 4: ERC721 items where a number of tokenIds are supported
    ERC721_WITH_CRITERIA,

    // 5: ERC1155 items where a number of ids are supported
    ERC1155_WITH_CRITERIA
}

// prettier-ignore
enum Side {
    // 0: Items that can be spent
    OFFER,

    // 1: Items that must be received
    CONSIDERATION
}

File 5 of 8 : ConsiderationStructs.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

// prettier-ignore
import {
    OrderType,
    BasicOrderType,
    ItemType,
    Side
} from "./ConsiderationEnums.sol";

/**
 * @dev An order contains eleven components: an offerer, a zone (or account that
 *      can cancel the order or restrict who can fulfill the order depending on
 *      the type), the order type (specifying partial fill support as well as
 *      restricted order status), the start and end time, a hash that will be
 *      provided to the zone when validating restricted orders, a salt, a key
 *      corresponding to a given conduit, a counter, and an arbitrary number of
 *      offer items that can be spent along with consideration items that must
 *      be received by their respective recipient.
 */
struct OrderComponents {
    address offerer;
    address zone;
    OfferItem[] offer;
    ConsiderationItem[] consideration;
    OrderType orderType;
    uint256 startTime;
    uint256 endTime;
    bytes32 zoneHash;
    uint256 salt;
    bytes32 conduitKey;
    uint256 counter;
}

/**
 * @dev An offer item has five components: an item type (ETH or other native
 *      tokens, ERC20, ERC721, and ERC1155, as well as criteria-based ERC721 and
 *      ERC1155), a token address, a dual-purpose "identifierOrCriteria"
 *      component that will either represent a tokenId or a merkle root
 *      depending on the item type, and a start and end amount that support
 *      increasing or decreasing amounts over the duration of the respective
 *      order.
 */
struct OfferItem {
    ItemType itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
}

/**
 * @dev A consideration item has the same five components as an offer item and
 *      an additional sixth component designating the required recipient of the
 *      item.
 */
struct ConsiderationItem {
    ItemType itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
    address payable recipient;
}

/**
 * @dev A spent item is translated from a utilized offer item and has four
 *      components: an item type (ETH or other native tokens, ERC20, ERC721, and
 *      ERC1155), a token address, a tokenId, and an amount.
 */
struct SpentItem {
    ItemType itemType;
    address token;
    uint256 identifier;
    uint256 amount;
}

/**
 * @dev A received item is translated from a utilized consideration item and has
 *      the same four components as a spent item, as well as an additional fifth
 *      component designating the required recipient of the item.
 */
struct ReceivedItem {
    ItemType itemType;
    address token;
    uint256 identifier;
    uint256 amount;
    address payable recipient;
}

/**
 * @dev For basic orders involving ETH / native / ERC20 <=> ERC721 / ERC1155
 *      matching, a group of six functions may be called that only requires a
 *      subset of the usual order arguments. Note the use of a "basicOrderType"
 *      enum; this represents both the usual order type as well as the "route"
 *      of the basic order (a simple derivation function for the basic order
 *      type is `basicOrderType = orderType + (4 * basicOrderRoute)`.)
 */
struct BasicOrderParameters {
    // calldata offset
    address considerationToken; // 0x24
    uint256 considerationIdentifier; // 0x44
    uint256 considerationAmount; // 0x64
    address payable offerer; // 0x84
    address zone; // 0xa4
    address offerToken; // 0xc4
    uint256 offerIdentifier; // 0xe4
    uint256 offerAmount; // 0x104
    BasicOrderType basicOrderType; // 0x124
    uint256 startTime; // 0x144
    uint256 endTime; // 0x164
    bytes32 zoneHash; // 0x184
    uint256 salt; // 0x1a4
    bytes32 offererConduitKey; // 0x1c4
    bytes32 fulfillerConduitKey; // 0x1e4
    uint256 totalOriginalAdditionalRecipients; // 0x204
    AdditionalRecipient[] additionalRecipients; // 0x224
    bytes signature; // 0x244
    // Total length, excluding dynamic array data: 0x264 (580)
}

/**
 * @dev Basic orders can supply any number of additional recipients, with the
 *      implied assumption that they are supplied from the offered ETH (or other
 *      native token) or ERC20 token for the order.
 */
struct AdditionalRecipient {
    uint256 amount;
    address payable recipient;
}

/**
 * @dev The full set of order components, with the exception of the counter,
 *      must be supplied when fulfilling more sophisticated orders or groups of
 *      orders. The total number of original consideration items must also be
 *      supplied, as the caller may specify additional consideration items.
 */
struct OrderParameters {
    address offerer; // 0x00
    address zone; // 0x20
    OfferItem[] offer; // 0x40
    ConsiderationItem[] consideration; // 0x60
    OrderType orderType; // 0x80
    uint256 startTime; // 0xa0
    uint256 endTime; // 0xc0
    bytes32 zoneHash; // 0xe0
    uint256 salt; // 0x100
    bytes32 conduitKey; // 0x120
    uint256 totalOriginalConsiderationItems; // 0x140
    // offer.length                          // 0x160
}

/**
 * @dev Orders require a signature in addition to the other order parameters.
 */
struct Order {
    OrderParameters parameters;
    bytes signature;
}

/**
 * @dev Advanced orders include a numerator (i.e. a fraction to attempt to fill)
 *      and a denominator (the total size of the order) in addition to the
 *      signature and other order parameters. It also supports an optional field
 *      for supplying extra data; this data will be included in a staticcall to
 *      `isValidOrderIncludingExtraData` on the zone for the order if the order
 *      type is restricted and the offerer or zone are not the caller.
 */
struct AdvancedOrder {
    OrderParameters parameters;
    uint120 numerator;
    uint120 denominator;
    bytes signature;
    bytes extraData;
}

/**
 * @dev Orders can be validated (either explicitly via `validate`, or as a
 *      consequence of a full or partial fill), specifically cancelled (they can
 *      also be cancelled in bulk via incrementing a per-zone counter), and
 *      partially or fully filled (with the fraction filled represented by a
 *      numerator and denominator).
 */
struct OrderStatus {
    bool isValidated;
    bool isCancelled;
    uint120 numerator;
    uint120 denominator;
}

/**
 * @dev A criteria resolver specifies an order, side (offer vs. consideration),
 *      and item index. It then provides a chosen identifier (i.e. tokenId)
 *      alongside a merkle proof demonstrating the identifier meets the required
 *      criteria.
 */
struct CriteriaResolver {
    uint256 orderIndex;
    Side side;
    uint256 index;
    uint256 identifier;
    bytes32[] criteriaProof;
}

/**
 * @dev A fulfillment is applied to a group of orders. It decrements a series of
 *      offer and consideration items, then generates a single execution
 *      element. A given fulfillment can be applied to as many offer and
 *      consideration items as desired, but must contain at least one offer and
 *      at least one consideration that match. The fulfillment must also remain
 *      consistent on all key parameters across all offer items (same offerer,
 *      token, type, tokenId, and conduit preference) as well as across all
 *      consideration items (token, type, tokenId, and recipient).
 */
struct Fulfillment {
    FulfillmentComponent[] offerComponents;
    FulfillmentComponent[] considerationComponents;
}

/**
 * @dev Each fulfillment component contains one index referencing a specific
 *      order and another referencing a specific offer or consideration item.
 */
struct FulfillmentComponent {
    uint256 orderIndex;
    uint256 itemIndex;
}

/**
 * @dev An execution is triggered once all consideration items have been zeroed
 *      out. It sends the item in question from the offerer to the item's
 *      recipient, optionally sourcing approvals from either this contract
 *      directly or from the offerer's chosen conduit if one is specified. An
 *      execution is not provided as an argument, but rather is derived via
 *      orders, criteria resolvers, and fulfillments (where the total number of
 *      executions will be less than or equal to the total number of indicated
 *      fulfillments) and returned as part of `matchOrders`.
 */
struct Execution {
    ReceivedItem item;
    address offerer;
    bytes32 conduitKey;
}

File 6 of 8 : IProxy.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {BasicOrder} from "../libraries/OrderStructs.sol";

interface IProxy {
    error InvalidCaller();

    /**
     * @notice Execute NFT sweeps in a single transaction
     * @param orders Orders to be executed
     * @param ordersExtraData Extra data for each order
     * @param extraData Extra data for the whole transaction
     * @param recipient The address to receive the purchased NFTs
     * @param isAtomic Flag to enable atomic trades (all or nothing)
     *                 or partial trades
     */
    function execute(
        BasicOrder[] calldata orders,
        bytes[] calldata ordersExtraData,
        bytes calldata extraData,
        address recipient,
        bool isAtomic
    ) external payable;
}

File 7 of 8 : SeaportInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

// prettier-ignore
import {
    BasicOrderParameters,
    OrderComponents,
    Fulfillment,
    FulfillmentComponent,
    Execution,
    Order,
    AdvancedOrder,
    OrderStatus,
    CriteriaResolver
} from "../libraries/seaport/ConsiderationStructs.sol";

/**
 * @title SeaportInterface
 * @author 0agegg
 * @custom:version 1.1
 * @notice Seaport is a generalized ETH/ERC20/ERC721/ERC1155 marketplace. It
 *         minimizes external calls to the greatest extent possible and provides
 *         lightweight methods for common routes as well as more flexible
 *         methods for composing advanced orders.
 *
 * @dev SeaportInterface contains all external function interfaces for Seaport.
 */
interface SeaportInterface {
    /**
     * @notice Fulfill an order offering an ERC721 token by supplying Ether (or
     *         the native token for the given chain) as consideration for the
     *         order. An arbitrary number of "additional recipients" may also be
     *         supplied which will each receive native tokens from the fulfiller
     *         as consideration.
     *
     * @param parameters Additional information on the fulfilled order. Note
     *                   that the offerer must first approve this contract (or
     *                   their preferred conduit if indicated by the order) for
     *                   their offered ERC721 token to be transferred.
     *
     * @return fulfilled A boolean indicating whether the order has been
     *                   successfully fulfilled.
     */
    function fulfillBasicOrder(BasicOrderParameters calldata parameters) external payable returns (bool fulfilled);

    /**
     * @notice Fulfill an order with an arbitrary number of items for offer and
     *         consideration. Note that this function does not support
     *         criteria-based orders or partial filling of orders (though
     *         filling the remainder of a partially-filled order is supported).
     *
     * @param order               The order to fulfill. Note that both the
     *                            offerer and the fulfiller must first approve
     *                            this contract (or the corresponding conduit if
     *                            indicated) to transfer any relevant tokens on
     *                            their behalf and that contracts must implement
     *                            `onERC1155Received` to receive ERC1155 tokens
     *                            as consideration.
     * @param fulfillerConduitKey A bytes32 value indicating what conduit, if
     *                            any, to source the fulfiller's token approvals
     *                            from. The zero hash signifies that no conduit
     *                            should be used, with direct approvals set on
     *                            Seaport.
     *
     * @return fulfilled A boolean indicating whether the order has been
     *                   successfully fulfilled.
     */
    function fulfillOrder(Order calldata order, bytes32 fulfillerConduitKey) external payable returns (bool fulfilled);

    /**
     * @notice Fill an order, fully or partially, with an arbitrary number of
     *         items for offer and consideration alongside criteria resolvers
     *         containing specific token identifiers and associated proofs.
     *
     * @param advancedOrder       The order to fulfill along with the fraction
     *                            of the order to attempt to fill. Note that
     *                            both the offerer and the fulfiller must first
     *                            approve this contract (or their preferred
     *                            conduit if indicated by the order) to transfer
     *                            any relevant tokens on their behalf and that
     *                            contracts must implement `onERC1155Received`
     *                            to receive ERC1155 tokens as consideration.
     *                            Also note that all offer and consideration
     *                            components must have no remainder after
     *                            multiplication of the respective amount with
     *                            the supplied fraction for the partial fill to
     *                            be considered valid.
     * @param criteriaResolvers   An array where each element contains a
     *                            reference to a specific offer or
     *                            consideration, a token identifier, and a proof
     *                            that the supplied token identifier is
     *                            contained in the merkle root held by the item
     *                            in question's criteria element. Note that an
     *                            empty criteria indicates that any
     *                            (transferable) token identifier on the token
     *                            in question is valid and that no associated
     *                            proof needs to be supplied.
     * @param fulfillerConduitKey A bytes32 value indicating what conduit, if
     *                            any, to source the fulfiller's token approvals
     *                            from. The zero hash signifies that no conduit
     *                            should be used, with direct approvals set on
     *                            Seaport.
     * @param recipient           The intended recipient for all received items,
     *                            with `address(0)` indicating that the caller
     *                            should receive the items.
     *
     * @return fulfilled A boolean indicating whether the order has been
     *                   successfully fulfilled.
     */
    function fulfillAdvancedOrder(
        AdvancedOrder calldata advancedOrder,
        CriteriaResolver[] calldata criteriaResolvers,
        bytes32 fulfillerConduitKey,
        address recipient
    ) external payable returns (bool fulfilled);

    /**
     * @notice Attempt to fill a group of orders, each with an arbitrary number
     *         of items for offer and consideration. Any order that is not
     *         currently active, has already been fully filled, or has been
     *         cancelled will be omitted. Remaining offer and consideration
     *         items will then be aggregated where possible as indicated by the
     *         supplied offer and consideration component arrays and aggregated
     *         items will be transferred to the fulfiller or to each intended
     *         recipient, respectively. Note that a failing item transfer or an
     *         issue with order formatting will cause the entire batch to fail.
     *         Note that this function does not support criteria-based orders or
     *         partial filling of orders (though filling the remainder of a
     *         partially-filled order is supported).
     *
     * @param orders                    The orders to fulfill. Note that both
     *                                  the offerer and the fulfiller must first
     *                                  approve this contract (or the
     *                                  corresponding conduit if indicated) to
     *                                  transfer any relevant tokens on their
     *                                  behalf and that contracts must implement
     *                                  `onERC1155Received` to receive ERC1155
     *                                  tokens as consideration.
     * @param offerFulfillments         An array of FulfillmentComponent arrays
     *                                  indicating which offer items to attempt
     *                                  to aggregate when preparing executions.
     * @param considerationFulfillments An array of FulfillmentComponent arrays
     *                                  indicating which consideration items to
     *                                  attempt to aggregate when preparing
     *                                  executions.
     * @param fulfillerConduitKey       A bytes32 value indicating what conduit,
     *                                  if any, to source the fulfiller's token
     *                                  approvals from. The zero hash signifies
     *                                  that no conduit should be used, with
     *                                  direct approvals set on this contract.
     * @param maximumFulfilled          The maximum number of orders to fulfill.
     *
     * @return availableOrders An array of booleans indicating if each order
     *                         with an index corresponding to the index of the
     *                         returned boolean was fulfillable or not.
     * @return executions      An array of elements indicating the sequence of
     *                         transfers performed as part of matching the given
     *                         orders.
     */
    function fulfillAvailableOrders(
        Order[] calldata orders,
        FulfillmentComponent[][] calldata offerFulfillments,
        FulfillmentComponent[][] calldata considerationFulfillments,
        bytes32 fulfillerConduitKey,
        uint256 maximumFulfilled
    ) external payable returns (bool[] memory availableOrders, Execution[] memory executions);

    /**
     * @notice Attempt to fill a group of orders, fully or partially, with an
     *         arbitrary number of items for offer and consideration per order
     *         alongside criteria resolvers containing specific token
     *         identifiers and associated proofs. Any order that is not
     *         currently active, has already been fully filled, or has been
     *         cancelled will be omitted. Remaining offer and consideration
     *         items will then be aggregated where possible as indicated by the
     *         supplied offer and consideration component arrays and aggregated
     *         items will be transferred to the fulfiller or to each intended
     *         recipient, respectively. Note that a failing item transfer or an
     *         issue with order formatting will cause the entire batch to fail.
     *
     * @param advancedOrders            The orders to fulfill along with the
     *                                  fraction of those orders to attempt to
     *                                  fill. Note that both the offerer and the
     *                                  fulfiller must first approve this
     *                                  contract (or their preferred conduit if
     *                                  indicated by the order) to transfer any
     *                                  relevant tokens on their behalf and that
     *                                  contracts must implement
     *                                  `onERC1155Received` to enable receipt of
     *                                  ERC1155 tokens as consideration. Also
     *                                  note that all offer and consideration
     *                                  components must have no remainder after
     *                                  multiplication of the respective amount
     *                                  with the supplied fraction for an
     *                                  order's partial fill amount to be
     *                                  considered valid.
     * @param criteriaResolvers         An array where each element contains a
     *                                  reference to a specific offer or
     *                                  consideration, a token identifier, and a
     *                                  proof that the supplied token identifier
     *                                  is contained in the merkle root held by
     *                                  the item in question's criteria element.
     *                                  Note that an empty criteria indicates
     *                                  that any (transferable) token
     *                                  identifier on the token in question is
     *                                  valid and that no associated proof needs
     *                                  to be supplied.
     * @param offerFulfillments         An array of FulfillmentComponent arrays
     *                                  indicating which offer items to attempt
     *                                  to aggregate when preparing executions.
     * @param considerationFulfillments An array of FulfillmentComponent arrays
     *                                  indicating which consideration items to
     *                                  attempt to aggregate when preparing
     *                                  executions.
     * @param fulfillerConduitKey       A bytes32 value indicating what conduit,
     *                                  if any, to source the fulfiller's token
     *                                  approvals from. The zero hash signifies
     *                                  that no conduit should be used, with
     *                                  direct approvals set on this contract.
     * @param recipient                 The intended recipient for all received
     *                                  items, with `address(0)` indicating that
     *                                  the caller should receive the items.
     * @param maximumFulfilled          The maximum number of orders to fulfill.
     *
     * @return availableOrders An array of booleans indicating if each order
     *                         with an index corresponding to the index of the
     *                         returned boolean was fulfillable or not.
     * @return executions      An array of elements indicating the sequence of
     *                         transfers performed as part of matching the given
     *                         orders.
     */
    function fulfillAvailableAdvancedOrders(
        AdvancedOrder[] calldata advancedOrders,
        CriteriaResolver[] calldata criteriaResolvers,
        FulfillmentComponent[][] calldata offerFulfillments,
        FulfillmentComponent[][] calldata considerationFulfillments,
        bytes32 fulfillerConduitKey,
        address recipient,
        uint256 maximumFulfilled
    ) external payable returns (bool[] memory availableOrders, Execution[] memory executions);

    /**
     * @notice Match an arbitrary number of orders, each with an arbitrary
     *         number of items for offer and consideration along with as set of
     *         fulfillments allocating offer components to consideration
     *         components. Note that this function does not support
     *         criteria-based or partial filling of orders (though filling the
     *         remainder of a partially-filled order is supported).
     *
     * @param orders       The orders to match. Note that both the offerer and
     *                     fulfiller on each order must first approve this
     *                     contract (or their conduit if indicated by the order)
     *                     to transfer any relevant tokens on their behalf and
     *                     each consideration recipient must implement
     *                     `onERC1155Received` to enable ERC1155 token receipt.
     * @param fulfillments An array of elements allocating offer components to
     *                     consideration components. Note that each
     *                     consideration component must be fully met for the
     *                     match operation to be valid.
     *
     * @return executions An array of elements indicating the sequence of
     *                    transfers performed as part of matching the given
     *                    orders.
     */
    function matchOrders(Order[] calldata orders, Fulfillment[] calldata fulfillments)
        external
        payable
        returns (Execution[] memory executions);

    /**
     * @notice Match an arbitrary number of full or partial orders, each with an
     *         arbitrary number of items for offer and consideration, supplying
     *         criteria resolvers containing specific token identifiers and
     *         associated proofs as well as fulfillments allocating offer
     *         components to consideration components.
     *
     * @param orders            The advanced orders to match. Note that both the
     *                          offerer and fulfiller on each order must first
     *                          approve this contract (or a preferred conduit if
     *                          indicated by the order) to transfer any relevant
     *                          tokens on their behalf and each consideration
     *                          recipient must implement `onERC1155Received` in
     *                          order to receive ERC1155 tokens. Also note that
     *                          the offer and consideration components for each
     *                          order must have no remainder after multiplying
     *                          the respective amount with the supplied fraction
     *                          in order for the group of partial fills to be
     *                          considered valid.
     * @param criteriaResolvers An array where each element contains a reference
     *                          to a specific order as well as that order's
     *                          offer or consideration, a token identifier, and
     *                          a proof that the supplied token identifier is
     *                          contained in the order's merkle root. Note that
     *                          an empty root indicates that any (transferable)
     *                          token identifier is valid and that no associated
     *                          proof needs to be supplied.
     * @param fulfillments      An array of elements allocating offer components
     *                          to consideration components. Note that each
     *                          consideration component must be fully met in
     *                          order for the match operation to be valid.
     *
     * @return executions An array of elements indicating the sequence of
     *                    transfers performed as part of matching the given
     *                    orders.
     */
    function matchAdvancedOrders(
        AdvancedOrder[] calldata orders,
        CriteriaResolver[] calldata criteriaResolvers,
        Fulfillment[] calldata fulfillments
    ) external payable returns (Execution[] memory executions);

    /**
     * @notice Cancel an arbitrary number of orders. Note that only the offerer
     *         or the zone of a given order may cancel it. Callers should ensure
     *         that the intended order was cancelled by calling `getOrderStatus`
     *         and confirming that `isCancelled` returns `true`.
     *
     * @param orders The orders to cancel.
     *
     * @return cancelled A boolean indicating whether the supplied orders have
     *                   been successfully cancelled.
     */
    function cancel(OrderComponents[] calldata orders) external returns (bool cancelled);

    /**
     * @notice Validate an arbitrary number of orders, thereby registering their
     *         signatures as valid and allowing the fulfiller to skip signature
     *         verification on fulfillment. Note that validated orders may still
     *         be unfulfillable due to invalid item amounts or other factors;
     *         callers should determine whether validated orders are fulfillable
     *         by simulating the fulfillment call prior to execution. Also note
     *         that anyone can validate a signed order, but only the offerer can
     *         validate an order without supplying a signature.
     *
     * @param orders The orders to validate.
     *
     * @return validated A boolean indicating whether the supplied orders have
     *                   been successfully validated.
     */
    function validate(Order[] calldata orders) external returns (bool validated);

    /**
     * @notice Cancel all orders from a given offerer with a given zone in bulk
     *         by incrementing a counter. Note that only the offerer may
     *         increment the counter.
     *
     * @return newCounter The new counter.
     */
    function incrementCounter() external returns (uint256 newCounter);

    /**
     * @notice Retrieve the order hash for a given order.
     *
     * @param order The components of the order.
     *
     * @return orderHash The order hash.
     */
    function getOrderHash(OrderComponents calldata order) external view returns (bytes32 orderHash);

    /**
     * @notice Retrieve the status of a given order by hash, including whether
     *         the order has been cancelled or validated and the fraction of the
     *         order that has been filled.
     *
     * @param orderHash The order hash in question.
     *
     * @return isValidated A boolean indicating whether the order in question
     *                     has been validated (i.e. previously approved or
     *                     partially filled).
     * @return isCancelled A boolean indicating whether the order in question
     *                     has been cancelled.
     * @return totalFilled The total portion of the order that has been filled
     *                     (i.e. the "numerator").
     * @return totalSize   The total size of the order that is either filled or
     *                     unfilled (i.e. the "denominator").
     */
    function getOrderStatus(bytes32 orderHash)
        external
        view
        returns (
            bool isValidated,
            bool isCancelled,
            uint256 totalFilled,
            uint256 totalSize
        );

    /**
     * @notice Retrieve the current counter for a given offerer.
     *
     * @param offerer The offerer in question.
     *
     * @return counter The current counter.
     */
    function getCounter(address offerer) external view returns (uint256 counter);

    /**
     * @notice Retrieve configuration information for this contract.
     *
     * @return version           The contract version.
     * @return domainSeparator   The domain separator for this contract.
     * @return conduitController The conduit Controller set for this contract.
     */
    function information()
        external
        view
        returns (
            string memory version,
            bytes32 domainSeparator,
            address conduitController
        );

    /**
     * @notice Retrieve the name of this contract.
     *
     * @return contractName The name of this contract.
     */
    function name() external view returns (string memory contractName);
}

File 8 of 8 : SharedErrors.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

error InvalidOrderLength();
error TradeExecutionFailed();
error ZeroAddress();

File 9 of 8 : OrderEnums.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

enum CollectionType {
    ERC721,
    ERC1155
}

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

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_marketplace","type":"address"},{"internalType":"address","name":"_aggregator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidCaller","type":"error"},{"inputs":[],"name":"InvalidOrderLength","type":"error"},{"inputs":[],"name":"TradeExecutionFailed","type":"error"},{"inputs":[],"name":"aggregator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"collection","type":"address"},{"internalType":"enum CollectionType","name":"collectionType","type":"uint8"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct BasicOrder[]","name":"orders","type":"tuple[]"},{"internalType":"bytes[]","name":"ordersExtraData","type":"bytes[]"},{"internalType":"bytes","name":"extraData","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bool","name":"isAtomic","type":"bool"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"marketplace","outputs":[{"internalType":"contract SeaportInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

Deployed Bytecode

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

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Txn Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.