Contract Name:
EarlyUnwindModule
Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// 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);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
// keccak256("wallet.YugaModule.lockedApe")
bytes32 constant APE_PLAN_LOCKER_SLOT = 0x010881fa8a1edce184936a8e4e08060bba49cb5145c9b396e6e80c0c6b0e1269;
// keccak256("wallet.ERC721Module.lockedERC721")
bytes32 constant CYAN_PLAN_LOCKER_SLOT_ERC721 = 0x25888debd3e1e584ccaebe1162c7763ec457a94078c5d0d9a1d32a926ff9973c;
// keccak256("wallet.ERC1155Module.lockedERC1155")
bytes32 constant CYAN_PLAN_LOCKER_SLOT_ERC1155 = 0xdcc609ac7fc3b6a216ce1445788736c9dbe88a58b25a13af71623e6da931efa0;
// keccak256("wallet.CryptoPunksModule.lockedCryptoPunks")
bytes32 constant CRYPTO_PUNKS_PLAN_LOCKER_SLOT = 0x67ae504a494a1bd5120fdcd8b3565de046d61ac7bb95311090f1976ec179a99a;
struct ApePlanLocker {
/// @notice Map of the locked tokens.
/// Note: Collection Address => Token ID => Lock state
mapping(address => mapping(uint256 => uint8)) tokens;
}
struct CyanPlanLockerERC721 {
/// @notice Locked tokens count of the collection.
/// Note: Collection Address => Number of locked tokens
mapping(address => uint256) count;
/// @notice Map of the locked tokens.
/// Note: Collection Address => Token ID => isLocked
mapping(address => mapping(uint256 => bool)) tokens;
}
struct CyanPlanLockerCryptoPunks {
/// @notice Locked tokens count of the CryptoPunks.
/// Note: Number of locked tokens
uint256 count;
/// @notice Map of the locked tokens.
/// Note: CryptoPunk index => isLocked
mapping(uint256 => bool) tokens;
}
struct CyanPlanLockerERC1155 {
/// @notice Map of the locked ERC1155 tokens.
/// Note: Collection Address => Token ID => amount
mapping(address => mapping(uint256 => uint256)) tokens;
}
/// @notice Checks whether the NFT is locked or not. This method checks both ERC721 lock and ApePlan lock.
/// @param collection Collection address.
/// @param tokenId Token ID.
/// @return isLocked Whether the token is locked or not.
function isLockedERC721(address collection, uint256 tokenId) view returns (bool) {
return isLockedByCyanPlanERC721(collection, tokenId) || isLockedByApePlan(collection, tokenId);
}
/// @notice Checks whether the ERC721 token is locked or not.
/// @param collection Collection address.
/// @param tokenId Token ID.
/// @return isLocked Whether the token is locked or not.
function isLockedByCyanPlanERC721(address collection, uint256 tokenId) view returns (bool) {
return getCyanPlanLockerERC721().tokens[collection][tokenId];
}
/// @notice Checks whether the CryptoPunks token is locked or not.
/// @param tokenId Token ID.
/// @return isLocked Whether the token is locked or not.
function isLockedByCryptoPunkPlan(uint256 tokenId) view returns (bool) {
return getCyanPlanLockerCryptoPunks().tokens[tokenId];
}
/// @notice Checks whether the BAYC, MAYC or BAKC token is locked or not.
/// @param collection Ape collection address.
/// @param tokenId Token ID.
/// @return isLocked Whether the token is ape locked or not.
function isLockedByApePlan(address collection, uint256 tokenId) view returns (bool) {
return getApePlanLocker().tokens[collection][tokenId] != 0;
}
/// @notice Returns amount of locked ERC1155Token items.
/// @param collection Collection address.
/// @param tokenId Token ID.
/// @return isLocked Whether the token is locked or not.
function getLockedERC1155Amount(address collection, uint256 tokenId) view returns (uint256) {
return getCyanPlanLockerERC1155().tokens[collection][tokenId];
}
/// @notice Returns ape lock state.
/// @param collection Ape collection address.
/// @param tokenId Token ID.
/// @return Ape locks state.
function getApeLockState(address collection, uint256 tokenId) view returns (uint8) {
return getApePlanLocker().tokens[collection][tokenId];
}
/// @dev Returns the map of the locked ERC721 tokens.
/// @return result CyanPlanLockerERC721 struct of the locked tokens.
/// Note: Collection Address => Token ID => isLocked
function getCyanPlanLockerERC721() pure returns (CyanPlanLockerERC721 storage result) {
assembly {
result.slot := CYAN_PLAN_LOCKER_SLOT_ERC721
}
}
/// @dev Returns the map of the locked ERC1155 tokens.
/// @return result CyanPlanERC1155Locker struct of the locked tokens.
/// Note: Collection Address => Token ID => locked amount
function getCyanPlanLockerERC1155() pure returns (CyanPlanLockerERC1155 storage result) {
assembly {
result.slot := CYAN_PLAN_LOCKER_SLOT_ERC1155
}
}
/// @dev Returns the map of the locked Crypto Punks.
/// @return result CryptoPunksPlanLocker struct of the locked tokens.
/// Note: CryptoPunk index => isLocked
function getCyanPlanLockerCryptoPunks() pure returns (CyanPlanLockerCryptoPunks storage result) {
assembly {
result.slot := CRYPTO_PUNKS_PLAN_LOCKER_SLOT
}
}
/// @dev Returns the map of the locked tokens.
/// @return result ApePlanLocker struct of the locked tokens.
/// Note: Collection Address => Token ID => Lock state
function getApePlanLocker() pure returns (ApePlanLocker storage result) {
assembly {
result.slot := APE_PLAN_LOCKER_SLOT
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
library Utils {
/// @notice Executes a transaction to the given address.
/// @param to Target address.
/// @param value Native token value to be sent to the address.
/// @param data Data to be sent to the address.
/// @return result Result of the transaciton.
function _execute(
address to,
uint256 value,
bytes memory data
) internal returns (bytes memory result) {
assembly {
let success := call(gas(), to, value, add(data, 0x20), mload(data), 0, 0)
mstore(result, returndatasize())
returndatacopy(add(result, 0x20), 0, returndatasize())
if eq(success, 0) {
revert(add(result, 0x20), returndatasize())
}
}
}
/// @notice Recover signer address from signature.
/// @param signedHash Arbitrary length data signed on the behalf of the wallet.
/// @param signature Signature byte array associated with signedHash.
/// @return Recovered signer address.
function recoverSigner(bytes32 signedHash, bytes memory signature) internal pure returns (address) {
uint8 v;
bytes32 r;
bytes32 s;
// we jump 32 (0x20) as the first slot of bytes contains the length
// we jump 65 (0x41) per signature
// for v we load 32 bytes ending with v (the first 31 come from s) then apply a mask
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
require(v == 27 || v == 28, "Bad v value in signature.");
address recoveredAddress = ecrecover(signedHash, v, r, s);
require(recoveredAddress != address(0), "ecrecover returned 0.");
return recoveredAddress;
}
/// @notice Helper method to parse the function selector from data.
/// @param data Any data to be parsed, mostly calldata of transaction.
/// @return result Parsed function sighash.
function parseFunctionSelector(bytes memory data) internal pure returns (bytes4 result) {
require(data.length >= 4, "Invalid data.");
assembly {
result := mload(add(data, 0x20))
}
}
/// @notice Parse uint256 from given data.
/// @param data Any data to be parsed, mostly calldata of transaction.
/// @param position Position in the data.
/// @return result Uint256 parsed from given data.
function getUint256At(bytes memory data, uint8 position) internal pure returns (uint256 result) {
assembly {
result := mload(add(data, add(position, 0x20)))
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IModule {
/// @notice Executes given transaction data to given address.
/// @param to Target contract address.
/// @param value Value of the given transaction.
/// @param data Calldata of the transaction.
/// @return Result of the execution.
function handleTransaction(
address to,
uint256 value,
bytes calldata data
) external payable returns (bytes memory);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
/// @title Cyan AddressProvider contract
/// @author Bulgantamir Gankhuyag - <[email protected]>
/// @author Naranbayar Uuganbayar - <[email protected]>
contract AddressProvider is Ownable {
error AddressNotFound(bytes32 id);
event AddressSet(bytes32 id, address newAddress);
mapping(bytes32 => address) public addresses;
constructor(address owner) {
transferOwnership(owner);
}
// @dev Sets an address for an id replacing the address saved in the addresses map
// @param id The id
// @param newAddress The address to set
function setAddress(bytes32 id, address newAddress) external onlyOwner {
addresses[id] = newAddress;
emit AddressSet(id, newAddress);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
// DataTypes
enum PawnCreateType {
REGULAR,
BEND_DAO,
REFINANCE
}
enum PaymentPlanStatus {
BNPL_CREATED,
BNPL_FUNDED,
BNPL_ACTIVE,
BNPL_DEFAULTED,
BNPL_REJECTED,
BNPL_COMPLETED,
BNPL_LIQUIDATED,
PAWN_ACTIVE,
PAWN_DEFAULTED,
PAWN_COMPLETED,
PAWN_LIQUIDATED
}
struct Plan {
uint256 amount;
uint32 downPaymentPercent;
uint32 interestRate;
uint32 serviceFeeRate;
uint32 term;
uint8 totalNumberOfPayments;
uint8 counterPaidPayments;
uint8 autoRepayStatus;
}
struct PaymentPlan {
Plan plan;
uint256 createdDate;
address cyanWalletAddress;
PaymentPlanStatus status;
}
struct Item {
uint256 amount;
uint256 tokenId;
address contractAddress;
address cyanVaultAddress;
// 1 -> ERC721
// 2 -> ERC1155
// 3 -> CryptoPunks
uint8 itemType;
}
struct PaymentAmountInfo {
uint256 loanAmount;
uint256 interestAmount;
uint256 serviceAmount;
}
// Errors
error InvalidSender();
error InvalidBlockNumber();
error InvalidSignature();
error InvalidServiceFeeRate();
error InvalidTokenPrice();
error InvalidInterestRate();
error InvalidDownPaymentPercent();
error InvalidDownPayment();
error InvalidAmount();
error InvalidTerm();
error InvalidPaidCount();
error InvalidStage();
error InvalidAddress();
error InvalidAutoRepaymentDate();
error InvalidAutoRepaymentStatus();
error InvalidTotalNumberOfPayments();
error InvalidReviveDate();
error InvalidItem();
error InvalidBaseDiscountRate();
error InvalidApeCoinPlan();
error InvalidBendDaoPlan();
error InvalidCurrency();
error InvalidCyanBuyer();
error InvalidSelector();
error EthTransferFailed();
error PaymentPlanAlreadyExists();
error PaymentPlanNotFound();
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/core/IModule.sol";
import "../helpers/Utils.sol";
import "../thirdparty/opensea/ISeaport.sol";
import "../core/Lockers.sol" as Lockers;
import "../main/payment-plan/PaymentPlanTypes.sol";
import { AddressProvider } from "../main/AddressProvider.sol";
/// @title Cyan Wallet EarlyUnwindModule Module for OpenSea
/// @author Bulgantamir Gankhuyag - <[email protected]>
/// @author Naranbayar Uuganbayar - <[email protected]>
/// @author Munkhzul Boldbaatar
contract EarlyUnwindModule is IModule {
AddressProvider private constant addressProvider = AddressProvider(0xCF9A19D879769aDaE5e4f31503AAECDa82568E55);
/// @inheritdoc IModule
function handleTransaction(
address collection,
uint256 value,
bytes calldata data
) public payable override returns (bytes memory) {
return Utils._execute(collection, value, data);
}
/// @notice Allows operators to sell the locked token for Opensea offer.
/// Note: Can only sell if token is locked.
function earlyUnwindOpensea(
uint256 payAmount,
uint256 sellPrice,
Item calldata item,
bytes calldata osData
) external {
require(item.itemType == 1, "Item type must be ERC721");
IERC20 currency = IERC20(addressProvider.addresses("WETH"));
IERC721 collection = IERC721(item.contractAddress);
require(!Lockers.isLockedByApePlan(item.contractAddress, item.tokenId), "Token has ape lock");
require(collection.ownerOf(item.tokenId) == address(this), "Token is not owned by the wallet");
uint256 userBalance = currency.balanceOf(address(this));
{
collection.approve(addressProvider.addresses("SEAPORT_CONDUIT"), item.tokenId);
Utils._execute(addressProvider.addresses("SEAPORT_1_5"), 0, osData);
}
require(!Lockers.isLockedByApePlan(item.contractAddress, item.tokenId), "Token has ape lock");
require(userBalance + sellPrice == currency.balanceOf(address(this)), "Insufficient balance");
require(collection.ownerOf(item.tokenId) != address(this), "Token is owned by the wallet");
currency.approve(msg.sender, payAmount);
}
/// @notice Allows operators to sell the locked token for Cyan offer.
/// Note: Can only sell if token is locked.
function earlyUnwindCyan(uint256 payAmount, address currencyAddress) external {
IERC20 currency = IERC20(currencyAddress == address(0) ? addressProvider.addresses("WETH") : currencyAddress);
currency.approve(msg.sender, payAmount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
/// @title Seaport Contract interface
interface ISeaport {
enum OrderType {
FULL_OPEN,
PARTIAL_OPEN,
FULL_RESTRICTED,
PARTIAL_RESTRICTED,
CONTRACT
}
enum ItemType {
NATIVE,
ERC20,
ERC721,
ERC1155,
ERC721_WITH_CRITERIA,
ERC1155_WITH_CRITERIA
}
enum Side {
OFFER,
CONSIDERATION
}
struct OfferItem {
ItemType itemType;
address token;
uint256 identifierOrCriteria;
uint256 startAmount;
uint256 endAmount;
}
struct ConsiderationItem {
ItemType itemType;
address token;
uint256 identifierOrCriteria;
uint256 startAmount;
uint256 endAmount;
address payable recipient;
}
struct OrderParameters {
address offerer;
address zone;
OfferItem[] offer;
ConsiderationItem[] consideration;
OrderType orderType;
uint256 startTime;
uint256 endTime;
bytes32 zoneHash;
uint256 salt;
bytes32 conduitKey;
uint256 totalOriginalConsiderationItems;
}
struct FulfillmentComponent {
uint256 orderIndex;
uint256 itemIndex;
}
struct Fulfillment {
FulfillmentComponent[] offerComponents;
FulfillmentComponent[] considerationComponents;
}
struct CriteriaResolver {
uint256 orderIndex;
Side side;
uint256 index;
uint256 identifier;
bytes32[] criteriaProof;
}
struct AdvancedOrder {
OrderParameters parameters;
uint120 numerator;
uint120 denominator;
bytes signature;
bytes extraData;
}
struct ReceivedItem {
ItemType itemType;
address token;
uint256 identifier;
uint256 amount;
address payable recipient;
}
struct Execution {
ReceivedItem item;
address offerer;
bytes32 conduitKey;
}
struct OfferData {
AdvancedOrder[] orders;
CriteriaResolver[] criteriaResolvers;
Fulfillment[] fulfillments;
address recipient;
}
function matchAdvancedOrders(
AdvancedOrder[] calldata orders,
CriteriaResolver[] calldata criteriaResolvers,
Fulfillment[] calldata fulfillments,
address recipient
) external payable returns (Execution[] calldata executions);
}