Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 66 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Generate Point T... | 20557954 | 10 days ago | IN | 0 ETH | 0.00027354 | ||||
Approve Consider... | 20556645 | 10 days ago | IN | 0 ETH | 0.00030477 | ||||
Generate Point T... | 20541025 | 12 days ago | IN | 0 ETH | 0.00041057 | ||||
Generate Point T... | 20526694 | 14 days ago | IN | 0 ETH | 0.00058681 | ||||
Generate Point T... | 20525486 | 14 days ago | IN | 0 ETH | 0.00034463 | ||||
Generate Point T... | 20516831 | 15 days ago | IN | 0 ETH | 0.00031346 | ||||
Generate Point T... | 20485079 | 20 days ago | IN | 0 ETH | 0.00470723 | ||||
Generate Point T... | 20478576 | 21 days ago | IN | 0 ETH | 0.00177315 | ||||
Generate Point T... | 20464064 | 23 days ago | IN | 0 ETH | 0.0022968 | ||||
Generate Point T... | 20445348 | 25 days ago | IN | 0 ETH | 0.00057138 | ||||
Generate Point T... | 20442014 | 26 days ago | IN | 0 ETH | 0.00249512 | ||||
Generate Point T... | 20435102 | 27 days ago | IN | 0 ETH | 0.0044797 | ||||
Generate Point T... | 20419789 | 29 days ago | IN | 0 ETH | 0.00167051 | ||||
Generate Point T... | 20416244 | 29 days ago | IN | 0 ETH | 0.00072636 | ||||
Generate Point T... | 20389765 | 33 days ago | IN | 0 ETH | 0.00085246 | ||||
Generate Point T... | 20353553 | 38 days ago | IN | 0 ETH | 0.00054207 | ||||
Generate Point T... | 20341201 | 40 days ago | IN | 0 ETH | 0.00320307 | ||||
Generate Point T... | 20341155 | 40 days ago | IN | 0 ETH | 0.00287744 | ||||
Generate Point T... | 20341108 | 40 days ago | IN | 0 ETH | 0.00204792 | ||||
Generate Point T... | 20316923 | 43 days ago | IN | 0 ETH | 0.00088543 | ||||
Generate Point T... | 20290768 | 47 days ago | IN | 0 ETH | 0.00079953 | ||||
Generate Point T... | 20290423 | 47 days ago | IN | 0 ETH | 0.0007584 | ||||
Generate Point T... | 20283668 | 48 days ago | IN | 0 ETH | 0.00168124 | ||||
Generate Point T... | 20283354 | 48 days ago | IN | 0 ETH | 0.00296642 | ||||
Generate Point T... | 20268754 | 50 days ago | IN | 0 ETH | 0.0006747 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
HourglassPYTGeneratorZone
Compiler Version
v0.8.25+commit.b61c2a91
Optimization Enabled:
Yes with 100000 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SeaportInterface} from "seaport-types/src/interfaces/SeaportInterface.sol"; import {Order, OrderParameters, OfferItem, ConsiderationItem} from "seaport-types/src/lib/ConsiderationStructs.sol"; import {ItemType, OrderType} from "seaport-types/src/lib/ConsiderationEnums.sol"; import "@interfaces/IHourglassDepositor.sol"; import "transient-goodies/TransientPrimitives.sol"; import "../utils/TwoStepOwnable.sol"; import "seaport-types/src/interfaces/ConduitInterface.sol"; import "seaport-types/src/conduit/lib/ConduitEnums.sol"; /** * @title Seaport Point Generator * @notice A contract to atomically generate Hourglass Restaking Points and execute their sale using RFQ swaps * facilitated by Seaport. * @author Based on the Ion Protocol Seaport (De)leverage contract: https://github.com/Ion-Protocol/ion-seaport/blob/50251105b4e404623ddd6ee2cc8606b33796013a/src/SeaportDeleverage.sol * * @dev The standard Seaport flow would go as follows: * * 1. An `offerrer` creates an `Order` and signs it. The `fulfiller` will * be given both the `Order` payload and the `signature`. The `fulfiller`'s * role is to execute the transaction. * * Inside an `Order`, there is * - an `offerer`: the signature that will be `ecrecover()`ed to verify * the integrity of the signature. * - an array of `Offer`s: Each `Offer` will have a token and an amount. * - an array of `Consideration`s: Each `Consideration` will have a token, * an amount and a recipient. * * 2. Seaport will verify the signature was signed by the `offerer`. * * 3. Seaport will iterate through all the `Offer`s and transfer the * specified amount of each token to the fulfiller from the offerer. * * 4. Seaport will iterate through all the `Consideration`s and transfer * the specified amount of each token from the fulfiller to the recipient. * * * To generate point tokens without the maker taking on exposure to the assets, we * need to use the Hourglass system to mint the point tokens to the taker and the * principal tokens to the maker. The depositor requires having the assets deposited * before minting the point tokens. This contract is designed to facilitate * this process by utilizing the Seaport conduit & intercepting the execution to * transfer assets not included in the Seaport Order. * * While this would not be possible in the standard Seaport flow, we engage in a * non-standard flow that hijacks the ERC20 `transferFrom()` to gain control * flow in between steps 3 and 4. Normally, if the `offerer` wanted to sign for * a trade between 100 Token A and 90 Token B, the `Order` payload would contain * an `Offer` of 100 Token A and a `Consideration` of 90 Token B to the * `offerer`'s address. * * However, to sign for the same trade to be executed through this contract, the * `Order` payload would still contain an `Offer` of 100 Token A. This indicates * the amount of point tokens to be generated, while the `Consideration` would * be the cost to the fulfiller for purchasing these point tokens. Utilizing the * conduit for all token transfers besides minted point and principal tokens, each * party involved in the process need only grant token approvals to the trusted * Seaport Conduit. * * This allows this contract to gain control flow in between steps 3 and 4 * through the `transferFrom()` function and Seaport still enforces the * `constraints` of the other `Consideration`s ensuring counterparty's terms. * By utilizing transient storage, we can communicate data between the initial call * and the Seaport callback without the gas cost of writing to state. */ contract HourglassPYTGeneratorZone is TwoStepOwnable { using TransientPrimitivesLib for uint256; using TransientPrimitivesLib for taddress; uint256 internal constant DEFAULT_UNENTERED = 0; uint256 internal constant AWAITING_CALLBACK = 1; tuint256 internal _lockState; taddress internal _tDepositor; taddress internal _tFulfiller; address private constant DEFAULT_ADDRESS = address(0); // Seaport and Conduit contracts SeaportInterface private constant SEAPORT = SeaportInterface(0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC); // 0x9352dA82F42c5bDDe9F0b2C19D635baE39142dD8 ConduitInterface private immutable _conduit; // 0xa8c94ae38b04140794a9394b76ac6d0a83ac0b02000000000000000000000000 bytes32 private immutable _conduitKey; bool private deactivated; mapping(address => bool) private _approvedTokens; constructor(address _owner, address __conduit, bytes32 __conduitKey) { _setInitialOwner(_owner); _conduit = ConduitInterface(__conduit); _conduitKey = __conduitKey; } /** * @dev Modifier to check that the callback can only be called by the Seaport contract. */ modifier onlySeaport() { if (msg.sender != address(SEAPORT)) revert MsgSenderMustBeSeaport(msg.sender); _; } /** * @notice Deactivate the contract. */ function deactivate() external onlyOwner { deactivated = true; } function approveConsiderationToken(address token) external onlyOwner { _approvedTokens[token] = true; IERC20(token).approve(address(SEAPORT), type(uint256).max); emit ConsiderationTokenApproved(token); } /** * @notice Atomically generate point tokens via the Hourglass system using Seaport. * * @dev * ```solidity * struct Order { * OrderParameters parameters; * bytes signature; * } * * 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 * } * * 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; * } * ``` * * REQUIRES: * - There should only be one token for the `Offer`. * - The offer token should be this contract's address. This is to allow this contract to * gain control flow. We also want to use the `transferFrom()` args to communicate data * to the `transferFrom()` callback. Any data that can't be fit into the `transferFrom()` * args will be communicated through transient storage. * - There should be one item in the `Consideration`. * - The `zone` must be this contract's address. * - The `zoneHash` must be decoded to the address of the depositor generating the points tokens. * - The `orderType` must be `FULL_RESTRICTED`. This means only the `zone`, * or the offerer, can fulfill the order. * - The `conduitKey` must be the Hourglass Conduit Key. * - The `totalOriginalConsiderationItems` must be 1. * * - The `Offer` item must be of type `ERC20`. * - The `startAmount` and `endAmount` of the `Offer` item must be equal. * * - The `Consideration` item must be of type `ERC20`. * - The `token` of the `Consideration` item must be an approved payment token, a token for * which this contract has approved the Conduit to transfer the consideration amount from. * - The `startAmount` and `endAmount` of the first `Consideration` item * communicate the amount the buyer is paying for the offer.startAmount of point tokens. * - The `recipient` of the first `Consideration` item must be `offer.offerer`. * * We don't constrain the `recipient` of the second `Consideration` item. * * It is technically possible for two distinct orders to have the same * parameters. The `salt` should be used to distinguish between two orders * with the same parameters. Otherwise, they will map to the same order hash * and only one of them will be able to be fulfilled. * * @param order Seaport order */ function generatePointTokens(Order calldata order) external { // forgefmt: disable-start if (deactivated) revert ContractDeactivated(); // check that the contract has not been entered if (_lockState.get() == AWAITING_CALLBACK) revert AlreadyEntered(); // enter the contract _lockState.set(AWAITING_CALLBACK); // validate the order parameters OrderParameters calldata params = order.parameters; if (params.offer.length != 1) revert OffersLengthMustBeOne(params.offer.length); if (params.consideration.length != 1) revert ConsiderationsLengthMustBeOne(params.consideration.length); if (params.zone != address(this)) revert ZoneMustBeThis(params.zone); if (params.orderType != OrderType.FULL_RESTRICTED) revert OrderTypeMustBeFullRestricted(params.orderType); if (params.conduitKey != bytes32(0)) revert ConduitKeyMismatch(params.conduitKey); if (params.totalOriginalConsiderationItems != 1) revert InvalidTotalOriginalConsiderationItems(); // extract the depositor address from the zoneHash address depositor = address(uint160(uint256(params.zoneHash))); if (depositor == address(0)) revert ZoneHashDoesNotContainDepositorAddress(params.zoneHash); // get the deposit token from the depositor address depositToken = IHourglassDepositor(depositor).getUnderlying(); // store the addresses in transient storage TransientPrimitivesLib.set(_tDepositor, depositor); TransientPrimitivesLib.set(_tFulfiller, msg.sender); // validate the offer item OfferItem calldata offer = params.offer[0]; if (offer.itemType != ItemType.ERC20) revert OItemTypeMustBeERC20(offer.itemType); if (offer.token != address(this)) revert OTokenMustBeThis(offer.token); if (offer.startAmount != offer.endAmount) { revert OfferAmountMismatch(offer.startAmount, offer.endAmount); } // validate the consideration item ConsiderationItem calldata consideration1 = params.consideration[0]; if (consideration1.itemType != ItemType.ERC20) revert C1TypeMustBeERC20(consideration1.itemType); if (consideration1.recipient != params.offerer) revert C1RecipientMustBeSender(consideration1.recipient); if (consideration1.startAmount != consideration1.endAmount) revert ConsiderationAmountMismatch(consideration1.startAmount, consideration1.endAmount); if (!_approvedTokens[consideration1.token]) revert ConsiderationTokenMustBeApproved(consideration1.token); // forgefmt: disable-end /** * @dev Fulfilling a basic order uses msg.sender as the fulfiller (this address). * The fulfiller must transfer the consideration token here first. * Seaport then transfers it from here to the offerer as part of settlement. * The Hourglass Depositor also needs the deposit token pushed into it from the offerer. * To prevent call interception at the depositor, the depositor must be locked in first. */ // lock the depositor in preparation for the transfer in of funds IHourglassDepositor(depositor).enter(offer.startAmount); // create the ConduitTransfer array ConduitTransfer[] memory transfers = new ConduitTransfer[](2); // transfer the deposit token & amount from offerer to depositor transfers[0] = ConduitTransfer({ itemType: ConduitItemType.ERC20, token: depositToken, from: params.offerer, to: depositor, identifier: 0, amount: offer.startAmount }); // transfer the payment token & amount from depositor to this address transfers[1] = ConduitTransfer({ itemType: ConduitItemType.ERC20, token: params.consideration[0].token, from: msg.sender, to: address(this), identifier: 0, amount: params.consideration[0].startAmount }); // utilize the conduit to transfer the deposit token from the offerer to the depositor bytes4 successKey = _conduit.execute(transfers); if (successKey != _conduit.execute.selector) revert ConduitTransferFailure(); // fulfill the order via Seaport SEAPORT.fulfillOrder(order, bytes32(0)); // un-enter the contract _lockState.set(DEFAULT_UNENTERED); // zero out the depositor and fulfiller addresses _tDepositor.set(DEFAULT_ADDRESS); _tFulfiller.set(DEFAULT_ADDRESS); } /** * @notice This callback is not meant to be called directly. * * @dev This function selector has been mined to match the `transferFrom()` * selector (`0x23b872dd`). We hijack the `transferFrom()` selector to be * able to use the default Seaport flow. This is a callback from Seaport to * give this contract control flow between the `Offer` being transferred and * the `Consideration` being transferred. * * In order to enforce that this function is only called through a * transaction initiated by this contract, we use the `onlyReentrant` * modifier. * * This function can only be called by the Seaport contract. * * The input arguments are used to communicate data necessary * for the callback context. Transient storage is used to communicate any * extra data that could not be fit into the `transferFrom()` args. * * @param maker The offerer selling point tokens * @param depositAmount The quantity of point tokens to generate */ function seaportCallback4878572495(address maker, address, uint256 depositAmount) external onlySeaport { // Rather than onlyReentrant, check directly that the contract has been entered already if (_lockState.get() == DEFAULT_UNENTERED) revert NotEnteredYet(); /** * Calls depositTo on the stored depositor * Must have already sent the depositor the funds * Mints the point tokens to the taker * Mints the principal tokens to the maker */ IHourglassDepositor(_tDepositor.get()).depositTo(maker, _tFulfiller.get(), depositAmount, true); } ///// GETTERS ///// function conduit() external view returns (address) { return address(_conduit); } function conduitKey() external view returns (bytes32) { return _conduitKey; } function seaport() external view returns (address) { return address(SEAPORT); } function isApprovedConsiderationToken(address token) external view returns (bool) { return _approvedTokens[token]; } event ConsiderationTokenApproved(address token); ///// ERRORS ///// error ContractDeactivated(); error ConduitTransferFailure(); // Callback error NotAwaitingCallback(); error MsgSenderMustBeSeaport(address msgSender); error NotEnteredYet(); error AlreadyEntered(); // Order parameters head validation error OffersLengthMustBeOne(uint256 length); error ConsiderationsLengthMustBeOne(uint256 length); error ZoneMustBeThis(address zone); error OrderTypeMustBeFullRestricted(OrderType orderType); error ConduitKeyMismatch(bytes32 conduitKey); error InvalidTotalOriginalConsiderationItems(); error ZoneHashDoesNotContainDepositorAddress(bytes32 zoneHash); // Consideration item 1 validation error C1TypeMustBeERC20(ItemType itemType); error C1RecipientMustBeSender(address invalidRecipient); error ConsiderationAmountMismatch(uint256 startAmount, uint256 endAmount); error ConsiderationTokenMustBeApproved(address token); // Offer item validation error OTokenMustBeThis(address token); error OItemTypeMustBeERC20(ItemType itemType); error OfferAmountMismatch(uint256 startAmount, uint256 endAmount); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.20; /** * @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 value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` 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 value) external returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import { AdvancedOrder, BasicOrderParameters, CriteriaResolver, Execution, Fulfillment, FulfillmentComponent, Order, OrderComponents } from "../lib/ConsiderationStructs.sol"; /** * @title SeaportInterface * @author 0age * @custom:version 1.6 * @notice Seaport is a generalized native token/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. Note that unspent offer item amounts or * native tokens will not be reflected as part of * this array. */ 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. Note that unspent offer item amounts or * native tokens will not be reflected as part of * this array. */ 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 a 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). Any unspent * offer item amounts or native tokens will be transferred to the * caller. * * @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. Note that unspent offer item amounts or * native tokens will not be reflected as part of this * array. */ 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. Any unspent offer item * amounts will be transferred to the designated recipient (with the * null address signifying to use the caller) and any unspent native * tokens will be returned to the caller. * * @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. * @param recipient The intended recipient for all unspent offer * item amounts, or the caller if the null address * is supplied. * * @return executions An array of elements indicating the sequence of * transfers performed as part of matching the given * orders. Note that unspent offer item amounts or native * tokens will not be reflected as part of this array. */ function matchAdvancedOrders( AdvancedOrder[] calldata orders, CriteriaResolver[] calldata criteriaResolvers, Fulfillment[] calldata fulfillments, address recipient ) 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 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. Note that this function costs less gas than * `fulfillBasicOrder` due to the zero bytes in the function * selector (0x00000000) which also results in earlier function * dispatch. * * @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_efficient_6GL6yc( BasicOrderParameters calldata parameters ) external payable returns (bool fulfilled); /** * @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 ); function getContractOffererNonce( address contractOfferer ) external view returns (uint256 nonce); /** * @notice Retrieve the name of this contract. * * @return contractName The name of this contract. */ function name() external view returns (string memory contractName); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import { BasicOrderType, ItemType, OrderType, Side } from "./ConsiderationEnums.sol"; import { CalldataPointer, MemoryPointer } from "../helpers/PointerLibraries.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 provided to the zone if the * order type is restricted and the zone is not the caller, or will be * provided to the offerer as context for contract order types. */ 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; } /** * @dev Restricted orders are validated post-execution by calling validateOrder * on the zone. This struct provides context about the order fulfillment * and any supplied extraData, as well as all order hashes fulfilled in a * call to a match or fulfillAvailable method. */ struct ZoneParameters { bytes32 orderHash; address fulfiller; address offerer; SpentItem[] offer; ReceivedItem[] consideration; bytes extraData; bytes32[] orderHashes; uint256 startTime; uint256 endTime; bytes32 zoneHash; } /** * @dev Zones and contract offerers can communicate which schemas they implement * along with any associated metadata related to each schema. */ struct Schema { uint256 id; bytes metadata; } using StructPointers for OrderComponents global; using StructPointers for OfferItem global; using StructPointers for ConsiderationItem global; using StructPointers for SpentItem global; using StructPointers for ReceivedItem global; using StructPointers for BasicOrderParameters global; using StructPointers for AdditionalRecipient global; using StructPointers for OrderParameters global; using StructPointers for Order global; using StructPointers for AdvancedOrder global; using StructPointers for OrderStatus global; using StructPointers for CriteriaResolver global; using StructPointers for Fulfillment global; using StructPointers for FulfillmentComponent global; using StructPointers for Execution global; using StructPointers for ZoneParameters global; /** * @dev This library provides a set of functions for converting structs to * pointers. */ library StructPointers { /** * @dev Get a MemoryPointer from OrderComponents. * * @param obj The OrderComponents object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( OrderComponents memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from OrderComponents. * * @param obj The OrderComponents object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( OrderComponents calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from OfferItem. * * @param obj The OfferItem object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( OfferItem memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from OfferItem. * * @param obj The OfferItem object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( OfferItem calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from ConsiderationItem. * * @param obj The ConsiderationItem object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( ConsiderationItem memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from ConsiderationItem. * * @param obj The ConsiderationItem object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( ConsiderationItem calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from SpentItem. * * @param obj The SpentItem object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( SpentItem memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from SpentItem. * * @param obj The SpentItem object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( SpentItem calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from ReceivedItem. * * @param obj The ReceivedItem object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( ReceivedItem memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from ReceivedItem. * * @param obj The ReceivedItem object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( ReceivedItem calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from BasicOrderParameters. * * @param obj The BasicOrderParameters object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( BasicOrderParameters memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from BasicOrderParameters. * * @param obj The BasicOrderParameters object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( BasicOrderParameters calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from AdditionalRecipient. * * @param obj The AdditionalRecipient object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( AdditionalRecipient memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from AdditionalRecipient. * * @param obj The AdditionalRecipient object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( AdditionalRecipient calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from OrderParameters. * * @param obj The OrderParameters object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( OrderParameters memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from OrderParameters. * * @param obj The OrderParameters object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( OrderParameters calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from Order. * * @param obj The Order object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( Order memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from Order. * * @param obj The Order object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( Order calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from AdvancedOrder. * * @param obj The AdvancedOrder object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( AdvancedOrder memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from AdvancedOrder. * * @param obj The AdvancedOrder object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( AdvancedOrder calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from OrderStatus. * * @param obj The OrderStatus object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( OrderStatus memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from OrderStatus. * * @param obj The OrderStatus object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( OrderStatus calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from CriteriaResolver. * * @param obj The CriteriaResolver object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( CriteriaResolver memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from CriteriaResolver. * * @param obj The CriteriaResolver object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( CriteriaResolver calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from Fulfillment. * * @param obj The Fulfillment object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( Fulfillment memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from Fulfillment. * * @param obj The Fulfillment object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( Fulfillment calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from FulfillmentComponent. * * @param obj The FulfillmentComponent object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( FulfillmentComponent memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from FulfillmentComponent. * * @param obj The FulfillmentComponent object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( FulfillmentComponent calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from Execution. * * @param obj The Execution object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( Execution memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from Execution. * * @param obj The Execution object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( Execution calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } /** * @dev Get a MemoryPointer from ZoneParameters. * * @param obj The ZoneParameters object. * * @return ptr The MemoryPointer. */ function toMemoryPointer( ZoneParameters memory obj ) internal pure returns (MemoryPointer ptr) { assembly { ptr := obj } } /** * @dev Get a CalldataPointer from ZoneParameters. * * @param obj The ZoneParameters object. * * @return ptr The CalldataPointer. */ function toCalldataPointer( ZoneParameters calldata obj ) internal pure returns (CalldataPointer ptr) { assembly { ptr := obj } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; 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, // 4: contract order type CONTRACT } 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 } 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 } 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 } enum Side { // 0: Items that can be spent OFFER, // 1: Items that must be received CONSIDERATION }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface IHourglassDepositor { // deposit function depositFor(address _account, uint256 _amount, bool receiveSplit) external; function depositTo(address principalRecipient, address pointRecipient, uint256 amount, bool receiveSplit) external; function enter(uint256 amount) external; // getters function maturity() external view returns (uint256); function getUnderlying() external view returns (address); function getPointToken() external view returns (address); function getPrincipalToken() external view returns (address); function getTokens() external view returns (address[] memory); // admin function setMaxDeposits(uint256 _maxDeposits) external; function recoverToken(address _token, address _rewardsDistributor) external returns (uint256 amount); } interface IEthFiLUSDDepositor { function mintLockedUnderlying(uint256 minMintReceivedSlippageBps, address lusdDepositAsset, address sourceOfFunds) external returns (uint256 amountDepositAssetMinted); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; /// @author philogy <https://github.com/philogy> struct tuint256 { uint256 __placeholder; } struct tint256 { uint256 __placeholder; } struct tbytes32 { uint256 __placeholder; } struct taddress { uint256 __placeholder; } using TransientPrimitivesLib for tuint256 global; using TransientPrimitivesLib for tint256 global; using TransientPrimitivesLib for tbytes32 global; using TransientPrimitivesLib for taddress global; library TransientPrimitivesLib { function get(tuint256 storage ptr) internal view returns (uint256 value) { /// @solidity memory-safe-assembly assembly { value := tload(ptr.slot) } } function get(tint256 storage ptr) internal view returns (int256 value) { /// @solidity memory-safe-assembly assembly { value := tload(ptr.slot) } } function get(tbytes32 storage ptr) internal view returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { value := tload(ptr.slot) } } function get(taddress storage ptr) internal view returns (address value) { /// @solidity memory-safe-assembly assembly { value := tload(ptr.slot) } } function set(tuint256 storage ptr, uint256 value) internal { /// @solidity memory-safe-assembly assembly { tstore(ptr.slot, value) } } function inc(tuint256 storage ptr, uint256 change) internal returns (uint256 newValue) { ptr.set(newValue = ptr.get() + change); } function dec(tuint256 storage ptr, uint256 change) internal returns (uint256 newValue) { ptr.set(newValue = ptr.get() - change); } function set(tint256 storage ptr, int256 value) internal { /// @solidity memory-safe-assembly assembly { tstore(ptr.slot, value) } } function inc(tint256 storage ptr, int256 change) internal returns (int256 newValue) { ptr.set(newValue = ptr.get() + change); } function dec(tint256 storage ptr, int256 change) internal returns (int256 newValue) { ptr.set(newValue = ptr.get() - change); } function set(tbytes32 storage ptr, bytes32 value) internal { /// @solidity memory-safe-assembly assembly { tstore(ptr.slot, value) } } function set(taddress storage ptr, address value) internal { /// @solidity memory-safe-assembly assembly { tstore(ptr.slot, value) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import "./TwoStepOwnableInterface.sol"; /** * @title TwoStepOwnable * @author OpenSea Protocol Team * @notice TwoStepOwnable provides access control for inheriting contracts, * where the ownership of the contract can be exchanged via a two step * process. A potential owner is set by the current owner by calling * `transferOwnership`, then accepted by the new potential owner by * calling `acceptOwnership`. */ abstract contract TwoStepOwnable is TwoStepOwnableInterface { // The address of the owner. address private _owner; // The address of the new potential owner. address private _potentialOwner; /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { // Ensure that the caller is the owner. if (msg.sender != _owner) { revert CallerIsNotOwner(); } // Continue with function execution. _; } /** * @notice Initiate ownership transfer by assigning a new potential owner * to this contract. Once set, the new potential owner may call * `acceptOwnership` to claim ownership. Only the owner may call * this function. * * @param newPotentialOwner The address for which to initiate ownership * transfer to. */ function transferOwnership(address newPotentialOwner) external override onlyOwner { // Ensure the new potential owner is not an invalid address. if (newPotentialOwner == address(0)) { revert NewPotentialOwnerIsNullAddress(); } // Emit an event indicating that the potential owner has been updated. emit PotentialOwnerUpdated(newPotentialOwner); // Set the new potential owner as the potential owner. _potentialOwner = newPotentialOwner; } /** * @notice Clear the currently set potential owner, if any. Only the owner * of this contract may call this function. */ function cancelOwnershipTransfer() external override onlyOwner { // Emit an event indicating that the potential owner has been cleared. emit PotentialOwnerUpdated(address(0)); // Clear the current new potential owner. delete _potentialOwner; } /** * @notice Accept ownership of this contract. Only the account that the * current owner has set as the new potential owner may call this * function. */ function acceptOwnership() external override { // Ensure the caller is the potential owner. if (msg.sender != _potentialOwner) { // Revert, indicating that caller is not current potential owner. revert CallerIsNotNewPotentialOwner(); } // Emit an event indicating that the potential owner has been cleared. emit PotentialOwnerUpdated(address(0)); // Clear the current new potential owner. delete _potentialOwner; // Set the caller as the owner of this contract. _setOwner(msg.sender); } /** * @notice An external view function that returns the potential owner. * * @return The address of the potential owner. */ function potentialOwner() external view override returns (address) { return _potentialOwner; } /** * @notice A public view function that returns the owner. * * @return The address of the owner. */ function owner() public view override returns (address) { return _owner; } /** * @notice Internal function that sets the inital owner of the base * contract. The initial owner must not already be set. * To be called in the constructor or when initializing a proxy. * * @param initialOwner The address to set for initial ownership. */ function _setInitialOwner(address initialOwner) internal { // Ensure that an initial owner has been supplied. if (initialOwner == address(0)) { revert InitialOwnerIsNullAddress(); } // Ensure that the owner has not already been set. if (_owner != address(0)) { revert OwnerAlreadySet(_owner); } // Set the initial owner. _setOwner(initialOwner); } /** * @notice Private function that sets a new owner and emits a corresponding * event. * * @param newOwner The address to assign as the new owner. */ function _setOwner(address newOwner) private { // Emit an event indicating that the new owner has been set. emit OwnershipTransferred(_owner, newOwner); // Set the new owner. _owner = newOwner; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import { ConduitBatch1155Transfer, ConduitTransfer } from "../conduit/lib/ConduitStructs.sol"; /** * @title ConduitInterface * @author 0age * @notice ConduitInterface contains all external function interfaces, events, * and errors for conduit contracts. */ interface ConduitInterface { /** * @dev Revert with an error when attempting to execute transfers using a * caller that does not have an open channel. */ error ChannelClosed(address channel); /** * @dev Revert with an error when attempting to update a channel to the * current status of that channel. */ error ChannelStatusAlreadySet(address channel, bool isOpen); /** * @dev Revert with an error when attempting to execute a transfer for an * item that does not have an ERC20/721/1155 item type. */ error InvalidItemType(); /** * @dev Revert with an error when attempting to update the status of a * channel from a caller that is not the conduit controller. */ error InvalidController(); /** * @dev Emit an event whenever a channel is opened or closed. * * @param channel The channel that has been updated. * @param open A boolean indicating whether the conduit is open or not. */ event ChannelUpdated(address indexed channel, bool open); /** * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller * with an open channel can call this function. * * @param transfers The ERC20/721/1155 transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function execute( ConduitTransfer[] calldata transfers ) external returns (bytes4 magicValue); /** * @notice Execute a sequence of batch 1155 transfers. Only a caller with an * open channel can call this function. * * @param batch1155Transfers The 1155 batch transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function executeBatch1155( ConduitBatch1155Transfer[] calldata batch1155Transfers ) external returns (bytes4 magicValue); /** * @notice Execute a sequence of transfers, both single and batch 1155. Only * a caller with an open channel can call this function. * * @param standardTransfers The ERC20/721/1155 transfers to perform. * @param batch1155Transfers The 1155 batch transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function executeWithBatch1155( ConduitTransfer[] calldata standardTransfers, ConduitBatch1155Transfer[] calldata batch1155Transfers ) external returns (bytes4 magicValue); /** * @notice Open or close a given channel. Only callable by the controller. * * @param channel The channel to open or close. * @param isOpen The status of the channel (either open or closed). */ function updateChannel(address channel, bool isOpen) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; enum ConduitItemType { NATIVE, // unused ERC20, ERC721, ERC1155 }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; type CalldataPointer is uint256; type ReturndataPointer is uint256; type MemoryPointer is uint256; using CalldataPointerLib for CalldataPointer global; using MemoryPointerLib for MemoryPointer global; using ReturndataPointerLib for ReturndataPointer global; using CalldataReaders for CalldataPointer global; using ReturndataReaders for ReturndataPointer global; using MemoryReaders for MemoryPointer global; using MemoryWriters for MemoryPointer global; CalldataPointer constant CalldataStart = CalldataPointer.wrap(0x04); MemoryPointer constant FreeMemoryPPtr = MemoryPointer.wrap(0x40); MemoryPointer constant ZeroSlotPtr = MemoryPointer.wrap(0x60); uint256 constant IdentityPrecompileAddress = 0x4; uint256 constant OffsetOrLengthMask = 0xffffffff; uint256 constant _OneWord = 0x20; uint256 constant _FreeMemoryPointerSlot = 0x40; /// @dev Allocates `size` bytes in memory by increasing the free memory pointer /// and returns the memory pointer to the first byte of the allocated region. // (Free functions cannot have visibility.) // solhint-disable-next-line func-visibility function malloc(uint256 size) pure returns (MemoryPointer mPtr) { assembly { mPtr := mload(_FreeMemoryPointerSlot) mstore(_FreeMemoryPointerSlot, add(mPtr, size)) } } // (Free functions cannot have visibility.) // solhint-disable-next-line func-visibility function getFreeMemoryPointer() pure returns (MemoryPointer mPtr) { mPtr = FreeMemoryPPtr.readMemoryPointer(); } // (Free functions cannot have visibility.) // solhint-disable-next-line func-visibility function setFreeMemoryPointer(MemoryPointer mPtr) pure { FreeMemoryPPtr.write(mPtr); } library CalldataPointerLib { function lt( CalldataPointer a, CalldataPointer b ) internal pure returns (bool c) { assembly { c := lt(a, b) } } function gt( CalldataPointer a, CalldataPointer b ) internal pure returns (bool c) { assembly { c := gt(a, b) } } function eq( CalldataPointer a, CalldataPointer b ) internal pure returns (bool c) { assembly { c := eq(a, b) } } function isNull(CalldataPointer a) internal pure returns (bool b) { assembly { b := iszero(a) } } /// @dev Resolves an offset stored at `cdPtr + headOffset` to a calldata. /// pointer `cdPtr` must point to some parent object with a dynamic /// type's head stored at `cdPtr + headOffset`. function pptrOffset( CalldataPointer cdPtr, uint256 headOffset ) internal pure returns (CalldataPointer cdPtrChild) { cdPtrChild = cdPtr.offset( cdPtr.offset(headOffset).readUint256() & OffsetOrLengthMask ); } /// @dev Resolves an offset stored at `cdPtr` to a calldata pointer. /// `cdPtr` must point to some parent object with a dynamic type as its /// first member, e.g. `struct { bytes data; }` function pptr( CalldataPointer cdPtr ) internal pure returns (CalldataPointer cdPtrChild) { cdPtrChild = cdPtr.offset(cdPtr.readUint256() & OffsetOrLengthMask); } /// @dev Returns the calldata pointer one word after `cdPtr`. function next( CalldataPointer cdPtr ) internal pure returns (CalldataPointer cdPtrNext) { assembly { cdPtrNext := add(cdPtr, _OneWord) } } /// @dev Returns the calldata pointer `_offset` bytes after `cdPtr`. function offset( CalldataPointer cdPtr, uint256 _offset ) internal pure returns (CalldataPointer cdPtrNext) { assembly { cdPtrNext := add(cdPtr, _offset) } } /// @dev Copies `size` bytes from calldata starting at `src` to memory at /// `dst`. function copy( CalldataPointer src, MemoryPointer dst, uint256 size ) internal pure { assembly { calldatacopy(dst, src, size) } } } library ReturndataPointerLib { function lt( ReturndataPointer a, ReturndataPointer b ) internal pure returns (bool c) { assembly { c := lt(a, b) } } function gt( ReturndataPointer a, ReturndataPointer b ) internal pure returns (bool c) { assembly { c := gt(a, b) } } function eq( ReturndataPointer a, ReturndataPointer b ) internal pure returns (bool c) { assembly { c := eq(a, b) } } function isNull(ReturndataPointer a) internal pure returns (bool b) { assembly { b := iszero(a) } } /// @dev Resolves an offset stored at `rdPtr + headOffset` to a returndata /// pointer. `rdPtr` must point to some parent object with a dynamic /// type's head stored at `rdPtr + headOffset`. function pptrOffset( ReturndataPointer rdPtr, uint256 headOffset ) internal pure returns (ReturndataPointer rdPtrChild) { rdPtrChild = rdPtr.offset( rdPtr.offset(headOffset).readUint256() & OffsetOrLengthMask ); } /// @dev Resolves an offset stored at `rdPtr` to a returndata pointer. /// `rdPtr` must point to some parent object with a dynamic type as its /// first member, e.g. `struct { bytes data; }` function pptr( ReturndataPointer rdPtr ) internal pure returns (ReturndataPointer rdPtrChild) { rdPtrChild = rdPtr.offset(rdPtr.readUint256() & OffsetOrLengthMask); } /// @dev Returns the returndata pointer one word after `cdPtr`. function next( ReturndataPointer rdPtr ) internal pure returns (ReturndataPointer rdPtrNext) { assembly { rdPtrNext := add(rdPtr, _OneWord) } } /// @dev Returns the returndata pointer `_offset` bytes after `cdPtr`. function offset( ReturndataPointer rdPtr, uint256 _offset ) internal pure returns (ReturndataPointer rdPtrNext) { assembly { rdPtrNext := add(rdPtr, _offset) } } /// @dev Copies `size` bytes from returndata starting at `src` to memory at /// `dst`. function copy( ReturndataPointer src, MemoryPointer dst, uint256 size ) internal pure { assembly { returndatacopy(dst, src, size) } } } library MemoryPointerLib { function copy( MemoryPointer src, MemoryPointer dst, uint256 size ) internal view { assembly { let success := staticcall( gas(), IdentityPrecompileAddress, src, size, dst, size ) if or(iszero(returndatasize()), iszero(success)) { revert(0, 0) } } } function lt( MemoryPointer a, MemoryPointer b ) internal pure returns (bool c) { assembly { c := lt(a, b) } } function gt( MemoryPointer a, MemoryPointer b ) internal pure returns (bool c) { assembly { c := gt(a, b) } } function eq( MemoryPointer a, MemoryPointer b ) internal pure returns (bool c) { assembly { c := eq(a, b) } } function isNull(MemoryPointer a) internal pure returns (bool b) { assembly { b := iszero(a) } } function hash( MemoryPointer ptr, uint256 length ) internal pure returns (bytes32 _hash) { assembly { _hash := keccak256(ptr, length) } } /// @dev Returns the memory pointer one word after `mPtr`. function next( MemoryPointer mPtr ) internal pure returns (MemoryPointer mPtrNext) { assembly { mPtrNext := add(mPtr, _OneWord) } } /// @dev Returns the memory pointer `_offset` bytes after `mPtr`. function offset( MemoryPointer mPtr, uint256 _offset ) internal pure returns (MemoryPointer mPtrNext) { assembly { mPtrNext := add(mPtr, _offset) } } /// @dev Resolves a pointer at `mPtr + headOffset` to a memory /// pointer. `mPtr` must point to some parent object with a dynamic /// type's pointer stored at `mPtr + headOffset`. function pptrOffset( MemoryPointer mPtr, uint256 headOffset ) internal pure returns (MemoryPointer mPtrChild) { mPtrChild = mPtr.offset(headOffset).readMemoryPointer(); } /// @dev Resolves a pointer stored at `mPtr` to a memory pointer. /// `mPtr` must point to some parent object with a dynamic type as its /// first member, e.g. `struct { bytes data; }` function pptr( MemoryPointer mPtr ) internal pure returns (MemoryPointer mPtrChild) { mPtrChild = mPtr.readMemoryPointer(); } } library CalldataReaders { /// @dev Reads the value at `cdPtr` and applies a mask to return only the /// last 4 bytes. function readMaskedUint256( CalldataPointer cdPtr ) internal pure returns (uint256 value) { value = cdPtr.readUint256() & OffsetOrLengthMask; } /// @dev Reads the bool at `cdPtr` in calldata. function readBool( CalldataPointer cdPtr ) internal pure returns (bool value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the address at `cdPtr` in calldata. function readAddress( CalldataPointer cdPtr ) internal pure returns (address value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes1 at `cdPtr` in calldata. function readBytes1( CalldataPointer cdPtr ) internal pure returns (bytes1 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes2 at `cdPtr` in calldata. function readBytes2( CalldataPointer cdPtr ) internal pure returns (bytes2 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes3 at `cdPtr` in calldata. function readBytes3( CalldataPointer cdPtr ) internal pure returns (bytes3 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes4 at `cdPtr` in calldata. function readBytes4( CalldataPointer cdPtr ) internal pure returns (bytes4 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes5 at `cdPtr` in calldata. function readBytes5( CalldataPointer cdPtr ) internal pure returns (bytes5 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes6 at `cdPtr` in calldata. function readBytes6( CalldataPointer cdPtr ) internal pure returns (bytes6 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes7 at `cdPtr` in calldata. function readBytes7( CalldataPointer cdPtr ) internal pure returns (bytes7 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes8 at `cdPtr` in calldata. function readBytes8( CalldataPointer cdPtr ) internal pure returns (bytes8 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes9 at `cdPtr` in calldata. function readBytes9( CalldataPointer cdPtr ) internal pure returns (bytes9 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes10 at `cdPtr` in calldata. function readBytes10( CalldataPointer cdPtr ) internal pure returns (bytes10 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes11 at `cdPtr` in calldata. function readBytes11( CalldataPointer cdPtr ) internal pure returns (bytes11 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes12 at `cdPtr` in calldata. function readBytes12( CalldataPointer cdPtr ) internal pure returns (bytes12 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes13 at `cdPtr` in calldata. function readBytes13( CalldataPointer cdPtr ) internal pure returns (bytes13 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes14 at `cdPtr` in calldata. function readBytes14( CalldataPointer cdPtr ) internal pure returns (bytes14 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes15 at `cdPtr` in calldata. function readBytes15( CalldataPointer cdPtr ) internal pure returns (bytes15 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes16 at `cdPtr` in calldata. function readBytes16( CalldataPointer cdPtr ) internal pure returns (bytes16 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes17 at `cdPtr` in calldata. function readBytes17( CalldataPointer cdPtr ) internal pure returns (bytes17 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes18 at `cdPtr` in calldata. function readBytes18( CalldataPointer cdPtr ) internal pure returns (bytes18 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes19 at `cdPtr` in calldata. function readBytes19( CalldataPointer cdPtr ) internal pure returns (bytes19 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes20 at `cdPtr` in calldata. function readBytes20( CalldataPointer cdPtr ) internal pure returns (bytes20 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes21 at `cdPtr` in calldata. function readBytes21( CalldataPointer cdPtr ) internal pure returns (bytes21 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes22 at `cdPtr` in calldata. function readBytes22( CalldataPointer cdPtr ) internal pure returns (bytes22 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes23 at `cdPtr` in calldata. function readBytes23( CalldataPointer cdPtr ) internal pure returns (bytes23 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes24 at `cdPtr` in calldata. function readBytes24( CalldataPointer cdPtr ) internal pure returns (bytes24 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes25 at `cdPtr` in calldata. function readBytes25( CalldataPointer cdPtr ) internal pure returns (bytes25 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes26 at `cdPtr` in calldata. function readBytes26( CalldataPointer cdPtr ) internal pure returns (bytes26 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes27 at `cdPtr` in calldata. function readBytes27( CalldataPointer cdPtr ) internal pure returns (bytes27 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes28 at `cdPtr` in calldata. function readBytes28( CalldataPointer cdPtr ) internal pure returns (bytes28 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes29 at `cdPtr` in calldata. function readBytes29( CalldataPointer cdPtr ) internal pure returns (bytes29 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes30 at `cdPtr` in calldata. function readBytes30( CalldataPointer cdPtr ) internal pure returns (bytes30 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes31 at `cdPtr` in calldata. function readBytes31( CalldataPointer cdPtr ) internal pure returns (bytes31 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the bytes32 at `cdPtr` in calldata. function readBytes32( CalldataPointer cdPtr ) internal pure returns (bytes32 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint8 at `cdPtr` in calldata. function readUint8( CalldataPointer cdPtr ) internal pure returns (uint8 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint16 at `cdPtr` in calldata. function readUint16( CalldataPointer cdPtr ) internal pure returns (uint16 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint24 at `cdPtr` in calldata. function readUint24( CalldataPointer cdPtr ) internal pure returns (uint24 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint32 at `cdPtr` in calldata. function readUint32( CalldataPointer cdPtr ) internal pure returns (uint32 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint40 at `cdPtr` in calldata. function readUint40( CalldataPointer cdPtr ) internal pure returns (uint40 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint48 at `cdPtr` in calldata. function readUint48( CalldataPointer cdPtr ) internal pure returns (uint48 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint56 at `cdPtr` in calldata. function readUint56( CalldataPointer cdPtr ) internal pure returns (uint56 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint64 at `cdPtr` in calldata. function readUint64( CalldataPointer cdPtr ) internal pure returns (uint64 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint72 at `cdPtr` in calldata. function readUint72( CalldataPointer cdPtr ) internal pure returns (uint72 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint80 at `cdPtr` in calldata. function readUint80( CalldataPointer cdPtr ) internal pure returns (uint80 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint88 at `cdPtr` in calldata. function readUint88( CalldataPointer cdPtr ) internal pure returns (uint88 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint96 at `cdPtr` in calldata. function readUint96( CalldataPointer cdPtr ) internal pure returns (uint96 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint104 at `cdPtr` in calldata. function readUint104( CalldataPointer cdPtr ) internal pure returns (uint104 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint112 at `cdPtr` in calldata. function readUint112( CalldataPointer cdPtr ) internal pure returns (uint112 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint120 at `cdPtr` in calldata. function readUint120( CalldataPointer cdPtr ) internal pure returns (uint120 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint128 at `cdPtr` in calldata. function readUint128( CalldataPointer cdPtr ) internal pure returns (uint128 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint136 at `cdPtr` in calldata. function readUint136( CalldataPointer cdPtr ) internal pure returns (uint136 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint144 at `cdPtr` in calldata. function readUint144( CalldataPointer cdPtr ) internal pure returns (uint144 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint152 at `cdPtr` in calldata. function readUint152( CalldataPointer cdPtr ) internal pure returns (uint152 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint160 at `cdPtr` in calldata. function readUint160( CalldataPointer cdPtr ) internal pure returns (uint160 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint168 at `cdPtr` in calldata. function readUint168( CalldataPointer cdPtr ) internal pure returns (uint168 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint176 at `cdPtr` in calldata. function readUint176( CalldataPointer cdPtr ) internal pure returns (uint176 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint184 at `cdPtr` in calldata. function readUint184( CalldataPointer cdPtr ) internal pure returns (uint184 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint192 at `cdPtr` in calldata. function readUint192( CalldataPointer cdPtr ) internal pure returns (uint192 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint200 at `cdPtr` in calldata. function readUint200( CalldataPointer cdPtr ) internal pure returns (uint200 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint208 at `cdPtr` in calldata. function readUint208( CalldataPointer cdPtr ) internal pure returns (uint208 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint216 at `cdPtr` in calldata. function readUint216( CalldataPointer cdPtr ) internal pure returns (uint216 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint224 at `cdPtr` in calldata. function readUint224( CalldataPointer cdPtr ) internal pure returns (uint224 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint232 at `cdPtr` in calldata. function readUint232( CalldataPointer cdPtr ) internal pure returns (uint232 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint240 at `cdPtr` in calldata. function readUint240( CalldataPointer cdPtr ) internal pure returns (uint240 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint248 at `cdPtr` in calldata. function readUint248( CalldataPointer cdPtr ) internal pure returns (uint248 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the uint256 at `cdPtr` in calldata. function readUint256( CalldataPointer cdPtr ) internal pure returns (uint256 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int8 at `cdPtr` in calldata. function readInt8( CalldataPointer cdPtr ) internal pure returns (int8 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int16 at `cdPtr` in calldata. function readInt16( CalldataPointer cdPtr ) internal pure returns (int16 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int24 at `cdPtr` in calldata. function readInt24( CalldataPointer cdPtr ) internal pure returns (int24 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int32 at `cdPtr` in calldata. function readInt32( CalldataPointer cdPtr ) internal pure returns (int32 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int40 at `cdPtr` in calldata. function readInt40( CalldataPointer cdPtr ) internal pure returns (int40 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int48 at `cdPtr` in calldata. function readInt48( CalldataPointer cdPtr ) internal pure returns (int48 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int56 at `cdPtr` in calldata. function readInt56( CalldataPointer cdPtr ) internal pure returns (int56 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int64 at `cdPtr` in calldata. function readInt64( CalldataPointer cdPtr ) internal pure returns (int64 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int72 at `cdPtr` in calldata. function readInt72( CalldataPointer cdPtr ) internal pure returns (int72 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int80 at `cdPtr` in calldata. function readInt80( CalldataPointer cdPtr ) internal pure returns (int80 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int88 at `cdPtr` in calldata. function readInt88( CalldataPointer cdPtr ) internal pure returns (int88 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int96 at `cdPtr` in calldata. function readInt96( CalldataPointer cdPtr ) internal pure returns (int96 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int104 at `cdPtr` in calldata. function readInt104( CalldataPointer cdPtr ) internal pure returns (int104 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int112 at `cdPtr` in calldata. function readInt112( CalldataPointer cdPtr ) internal pure returns (int112 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int120 at `cdPtr` in calldata. function readInt120( CalldataPointer cdPtr ) internal pure returns (int120 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int128 at `cdPtr` in calldata. function readInt128( CalldataPointer cdPtr ) internal pure returns (int128 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int136 at `cdPtr` in calldata. function readInt136( CalldataPointer cdPtr ) internal pure returns (int136 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int144 at `cdPtr` in calldata. function readInt144( CalldataPointer cdPtr ) internal pure returns (int144 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int152 at `cdPtr` in calldata. function readInt152( CalldataPointer cdPtr ) internal pure returns (int152 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int160 at `cdPtr` in calldata. function readInt160( CalldataPointer cdPtr ) internal pure returns (int160 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int168 at `cdPtr` in calldata. function readInt168( CalldataPointer cdPtr ) internal pure returns (int168 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int176 at `cdPtr` in calldata. function readInt176( CalldataPointer cdPtr ) internal pure returns (int176 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int184 at `cdPtr` in calldata. function readInt184( CalldataPointer cdPtr ) internal pure returns (int184 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int192 at `cdPtr` in calldata. function readInt192( CalldataPointer cdPtr ) internal pure returns (int192 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int200 at `cdPtr` in calldata. function readInt200( CalldataPointer cdPtr ) internal pure returns (int200 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int208 at `cdPtr` in calldata. function readInt208( CalldataPointer cdPtr ) internal pure returns (int208 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int216 at `cdPtr` in calldata. function readInt216( CalldataPointer cdPtr ) internal pure returns (int216 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int224 at `cdPtr` in calldata. function readInt224( CalldataPointer cdPtr ) internal pure returns (int224 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int232 at `cdPtr` in calldata. function readInt232( CalldataPointer cdPtr ) internal pure returns (int232 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int240 at `cdPtr` in calldata. function readInt240( CalldataPointer cdPtr ) internal pure returns (int240 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int248 at `cdPtr` in calldata. function readInt248( CalldataPointer cdPtr ) internal pure returns (int248 value) { assembly { value := calldataload(cdPtr) } } /// @dev Reads the int256 at `cdPtr` in calldata. function readInt256( CalldataPointer cdPtr ) internal pure returns (int256 value) { assembly { value := calldataload(cdPtr) } } } library ReturndataReaders { /// @dev Reads value at `rdPtr` & applies a mask to return only last 4 bytes function readMaskedUint256( ReturndataPointer rdPtr ) internal pure returns (uint256 value) { value = rdPtr.readUint256() & OffsetOrLengthMask; } /// @dev Reads the bool at `rdPtr` in returndata. function readBool( ReturndataPointer rdPtr ) internal pure returns (bool value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the address at `rdPtr` in returndata. function readAddress( ReturndataPointer rdPtr ) internal pure returns (address value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes1 at `rdPtr` in returndata. function readBytes1( ReturndataPointer rdPtr ) internal pure returns (bytes1 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes2 at `rdPtr` in returndata. function readBytes2( ReturndataPointer rdPtr ) internal pure returns (bytes2 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes3 at `rdPtr` in returndata. function readBytes3( ReturndataPointer rdPtr ) internal pure returns (bytes3 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes4 at `rdPtr` in returndata. function readBytes4( ReturndataPointer rdPtr ) internal pure returns (bytes4 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes5 at `rdPtr` in returndata. function readBytes5( ReturndataPointer rdPtr ) internal pure returns (bytes5 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes6 at `rdPtr` in returndata. function readBytes6( ReturndataPointer rdPtr ) internal pure returns (bytes6 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes7 at `rdPtr` in returndata. function readBytes7( ReturndataPointer rdPtr ) internal pure returns (bytes7 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes8 at `rdPtr` in returndata. function readBytes8( ReturndataPointer rdPtr ) internal pure returns (bytes8 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes9 at `rdPtr` in returndata. function readBytes9( ReturndataPointer rdPtr ) internal pure returns (bytes9 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes10 at `rdPtr` in returndata. function readBytes10( ReturndataPointer rdPtr ) internal pure returns (bytes10 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes11 at `rdPtr` in returndata. function readBytes11( ReturndataPointer rdPtr ) internal pure returns (bytes11 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes12 at `rdPtr` in returndata. function readBytes12( ReturndataPointer rdPtr ) internal pure returns (bytes12 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes13 at `rdPtr` in returndata. function readBytes13( ReturndataPointer rdPtr ) internal pure returns (bytes13 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes14 at `rdPtr` in returndata. function readBytes14( ReturndataPointer rdPtr ) internal pure returns (bytes14 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes15 at `rdPtr` in returndata. function readBytes15( ReturndataPointer rdPtr ) internal pure returns (bytes15 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes16 at `rdPtr` in returndata. function readBytes16( ReturndataPointer rdPtr ) internal pure returns (bytes16 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes17 at `rdPtr` in returndata. function readBytes17( ReturndataPointer rdPtr ) internal pure returns (bytes17 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes18 at `rdPtr` in returndata. function readBytes18( ReturndataPointer rdPtr ) internal pure returns (bytes18 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes19 at `rdPtr` in returndata. function readBytes19( ReturndataPointer rdPtr ) internal pure returns (bytes19 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes20 at `rdPtr` in returndata. function readBytes20( ReturndataPointer rdPtr ) internal pure returns (bytes20 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes21 at `rdPtr` in returndata. function readBytes21( ReturndataPointer rdPtr ) internal pure returns (bytes21 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes22 at `rdPtr` in returndata. function readBytes22( ReturndataPointer rdPtr ) internal pure returns (bytes22 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes23 at `rdPtr` in returndata. function readBytes23( ReturndataPointer rdPtr ) internal pure returns (bytes23 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes24 at `rdPtr` in returndata. function readBytes24( ReturndataPointer rdPtr ) internal pure returns (bytes24 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes25 at `rdPtr` in returndata. function readBytes25( ReturndataPointer rdPtr ) internal pure returns (bytes25 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes26 at `rdPtr` in returndata. function readBytes26( ReturndataPointer rdPtr ) internal pure returns (bytes26 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes27 at `rdPtr` in returndata. function readBytes27( ReturndataPointer rdPtr ) internal pure returns (bytes27 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes28 at `rdPtr` in returndata. function readBytes28( ReturndataPointer rdPtr ) internal pure returns (bytes28 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes29 at `rdPtr` in returndata. function readBytes29( ReturndataPointer rdPtr ) internal pure returns (bytes29 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes30 at `rdPtr` in returndata. function readBytes30( ReturndataPointer rdPtr ) internal pure returns (bytes30 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes31 at `rdPtr` in returndata. function readBytes31( ReturndataPointer rdPtr ) internal pure returns (bytes31 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the bytes32 at `rdPtr` in returndata. function readBytes32( ReturndataPointer rdPtr ) internal pure returns (bytes32 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint8 at `rdPtr` in returndata. function readUint8( ReturndataPointer rdPtr ) internal pure returns (uint8 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint16 at `rdPtr` in returndata. function readUint16( ReturndataPointer rdPtr ) internal pure returns (uint16 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint24 at `rdPtr` in returndata. function readUint24( ReturndataPointer rdPtr ) internal pure returns (uint24 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint32 at `rdPtr` in returndata. function readUint32( ReturndataPointer rdPtr ) internal pure returns (uint32 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint40 at `rdPtr` in returndata. function readUint40( ReturndataPointer rdPtr ) internal pure returns (uint40 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint48 at `rdPtr` in returndata. function readUint48( ReturndataPointer rdPtr ) internal pure returns (uint48 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint56 at `rdPtr` in returndata. function readUint56( ReturndataPointer rdPtr ) internal pure returns (uint56 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint64 at `rdPtr` in returndata. function readUint64( ReturndataPointer rdPtr ) internal pure returns (uint64 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint72 at `rdPtr` in returndata. function readUint72( ReturndataPointer rdPtr ) internal pure returns (uint72 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint80 at `rdPtr` in returndata. function readUint80( ReturndataPointer rdPtr ) internal pure returns (uint80 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint88 at `rdPtr` in returndata. function readUint88( ReturndataPointer rdPtr ) internal pure returns (uint88 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint96 at `rdPtr` in returndata. function readUint96( ReturndataPointer rdPtr ) internal pure returns (uint96 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint104 at `rdPtr` in returndata. function readUint104( ReturndataPointer rdPtr ) internal pure returns (uint104 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint112 at `rdPtr` in returndata. function readUint112( ReturndataPointer rdPtr ) internal pure returns (uint112 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint120 at `rdPtr` in returndata. function readUint120( ReturndataPointer rdPtr ) internal pure returns (uint120 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint128 at `rdPtr` in returndata. function readUint128( ReturndataPointer rdPtr ) internal pure returns (uint128 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint136 at `rdPtr` in returndata. function readUint136( ReturndataPointer rdPtr ) internal pure returns (uint136 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint144 at `rdPtr` in returndata. function readUint144( ReturndataPointer rdPtr ) internal pure returns (uint144 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint152 at `rdPtr` in returndata. function readUint152( ReturndataPointer rdPtr ) internal pure returns (uint152 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint160 at `rdPtr` in returndata. function readUint160( ReturndataPointer rdPtr ) internal pure returns (uint160 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint168 at `rdPtr` in returndata. function readUint168( ReturndataPointer rdPtr ) internal pure returns (uint168 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint176 at `rdPtr` in returndata. function readUint176( ReturndataPointer rdPtr ) internal pure returns (uint176 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint184 at `rdPtr` in returndata. function readUint184( ReturndataPointer rdPtr ) internal pure returns (uint184 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint192 at `rdPtr` in returndata. function readUint192( ReturndataPointer rdPtr ) internal pure returns (uint192 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint200 at `rdPtr` in returndata. function readUint200( ReturndataPointer rdPtr ) internal pure returns (uint200 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint208 at `rdPtr` in returndata. function readUint208( ReturndataPointer rdPtr ) internal pure returns (uint208 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint216 at `rdPtr` in returndata. function readUint216( ReturndataPointer rdPtr ) internal pure returns (uint216 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint224 at `rdPtr` in returndata. function readUint224( ReturndataPointer rdPtr ) internal pure returns (uint224 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint232 at `rdPtr` in returndata. function readUint232( ReturndataPointer rdPtr ) internal pure returns (uint232 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint240 at `rdPtr` in returndata. function readUint240( ReturndataPointer rdPtr ) internal pure returns (uint240 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint248 at `rdPtr` in returndata. function readUint248( ReturndataPointer rdPtr ) internal pure returns (uint248 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the uint256 at `rdPtr` in returndata. function readUint256( ReturndataPointer rdPtr ) internal pure returns (uint256 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int8 at `rdPtr` in returndata. function readInt8( ReturndataPointer rdPtr ) internal pure returns (int8 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int16 at `rdPtr` in returndata. function readInt16( ReturndataPointer rdPtr ) internal pure returns (int16 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int24 at `rdPtr` in returndata. function readInt24( ReturndataPointer rdPtr ) internal pure returns (int24 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int32 at `rdPtr` in returndata. function readInt32( ReturndataPointer rdPtr ) internal pure returns (int32 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int40 at `rdPtr` in returndata. function readInt40( ReturndataPointer rdPtr ) internal pure returns (int40 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int48 at `rdPtr` in returndata. function readInt48( ReturndataPointer rdPtr ) internal pure returns (int48 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int56 at `rdPtr` in returndata. function readInt56( ReturndataPointer rdPtr ) internal pure returns (int56 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int64 at `rdPtr` in returndata. function readInt64( ReturndataPointer rdPtr ) internal pure returns (int64 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int72 at `rdPtr` in returndata. function readInt72( ReturndataPointer rdPtr ) internal pure returns (int72 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int80 at `rdPtr` in returndata. function readInt80( ReturndataPointer rdPtr ) internal pure returns (int80 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int88 at `rdPtr` in returndata. function readInt88( ReturndataPointer rdPtr ) internal pure returns (int88 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int96 at `rdPtr` in returndata. function readInt96( ReturndataPointer rdPtr ) internal pure returns (int96 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int104 at `rdPtr` in returndata. function readInt104( ReturndataPointer rdPtr ) internal pure returns (int104 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int112 at `rdPtr` in returndata. function readInt112( ReturndataPointer rdPtr ) internal pure returns (int112 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int120 at `rdPtr` in returndata. function readInt120( ReturndataPointer rdPtr ) internal pure returns (int120 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int128 at `rdPtr` in returndata. function readInt128( ReturndataPointer rdPtr ) internal pure returns (int128 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int136 at `rdPtr` in returndata. function readInt136( ReturndataPointer rdPtr ) internal pure returns (int136 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int144 at `rdPtr` in returndata. function readInt144( ReturndataPointer rdPtr ) internal pure returns (int144 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int152 at `rdPtr` in returndata. function readInt152( ReturndataPointer rdPtr ) internal pure returns (int152 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int160 at `rdPtr` in returndata. function readInt160( ReturndataPointer rdPtr ) internal pure returns (int160 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int168 at `rdPtr` in returndata. function readInt168( ReturndataPointer rdPtr ) internal pure returns (int168 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int176 at `rdPtr` in returndata. function readInt176( ReturndataPointer rdPtr ) internal pure returns (int176 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int184 at `rdPtr` in returndata. function readInt184( ReturndataPointer rdPtr ) internal pure returns (int184 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int192 at `rdPtr` in returndata. function readInt192( ReturndataPointer rdPtr ) internal pure returns (int192 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int200 at `rdPtr` in returndata. function readInt200( ReturndataPointer rdPtr ) internal pure returns (int200 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int208 at `rdPtr` in returndata. function readInt208( ReturndataPointer rdPtr ) internal pure returns (int208 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int216 at `rdPtr` in returndata. function readInt216( ReturndataPointer rdPtr ) internal pure returns (int216 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int224 at `rdPtr` in returndata. function readInt224( ReturndataPointer rdPtr ) internal pure returns (int224 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int232 at `rdPtr` in returndata. function readInt232( ReturndataPointer rdPtr ) internal pure returns (int232 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int240 at `rdPtr` in returndata. function readInt240( ReturndataPointer rdPtr ) internal pure returns (int240 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int248 at `rdPtr` in returndata. function readInt248( ReturndataPointer rdPtr ) internal pure returns (int248 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } /// @dev Reads the int256 at `rdPtr` in returndata. function readInt256( ReturndataPointer rdPtr ) internal pure returns (int256 value) { assembly { returndatacopy(0, rdPtr, _OneWord) value := mload(0) } } } library MemoryReaders { /// @dev Reads the memory pointer at `mPtr` in memory. function readMemoryPointer( MemoryPointer mPtr ) internal pure returns (MemoryPointer value) { assembly { value := mload(mPtr) } } /// @dev Reads value at `mPtr` & applies a mask to return only last 4 bytes function readMaskedUint256( MemoryPointer mPtr ) internal pure returns (uint256 value) { value = mPtr.readUint256() & OffsetOrLengthMask; } /// @dev Reads the bool at `mPtr` in memory. function readBool(MemoryPointer mPtr) internal pure returns (bool value) { assembly { value := mload(mPtr) } } /// @dev Reads the address at `mPtr` in memory. function readAddress( MemoryPointer mPtr ) internal pure returns (address value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes1 at `mPtr` in memory. function readBytes1( MemoryPointer mPtr ) internal pure returns (bytes1 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes2 at `mPtr` in memory. function readBytes2( MemoryPointer mPtr ) internal pure returns (bytes2 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes3 at `mPtr` in memory. function readBytes3( MemoryPointer mPtr ) internal pure returns (bytes3 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes4 at `mPtr` in memory. function readBytes4( MemoryPointer mPtr ) internal pure returns (bytes4 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes5 at `mPtr` in memory. function readBytes5( MemoryPointer mPtr ) internal pure returns (bytes5 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes6 at `mPtr` in memory. function readBytes6( MemoryPointer mPtr ) internal pure returns (bytes6 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes7 at `mPtr` in memory. function readBytes7( MemoryPointer mPtr ) internal pure returns (bytes7 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes8 at `mPtr` in memory. function readBytes8( MemoryPointer mPtr ) internal pure returns (bytes8 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes9 at `mPtr` in memory. function readBytes9( MemoryPointer mPtr ) internal pure returns (bytes9 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes10 at `mPtr` in memory. function readBytes10( MemoryPointer mPtr ) internal pure returns (bytes10 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes11 at `mPtr` in memory. function readBytes11( MemoryPointer mPtr ) internal pure returns (bytes11 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes12 at `mPtr` in memory. function readBytes12( MemoryPointer mPtr ) internal pure returns (bytes12 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes13 at `mPtr` in memory. function readBytes13( MemoryPointer mPtr ) internal pure returns (bytes13 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes14 at `mPtr` in memory. function readBytes14( MemoryPointer mPtr ) internal pure returns (bytes14 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes15 at `mPtr` in memory. function readBytes15( MemoryPointer mPtr ) internal pure returns (bytes15 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes16 at `mPtr` in memory. function readBytes16( MemoryPointer mPtr ) internal pure returns (bytes16 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes17 at `mPtr` in memory. function readBytes17( MemoryPointer mPtr ) internal pure returns (bytes17 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes18 at `mPtr` in memory. function readBytes18( MemoryPointer mPtr ) internal pure returns (bytes18 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes19 at `mPtr` in memory. function readBytes19( MemoryPointer mPtr ) internal pure returns (bytes19 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes20 at `mPtr` in memory. function readBytes20( MemoryPointer mPtr ) internal pure returns (bytes20 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes21 at `mPtr` in memory. function readBytes21( MemoryPointer mPtr ) internal pure returns (bytes21 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes22 at `mPtr` in memory. function readBytes22( MemoryPointer mPtr ) internal pure returns (bytes22 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes23 at `mPtr` in memory. function readBytes23( MemoryPointer mPtr ) internal pure returns (bytes23 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes24 at `mPtr` in memory. function readBytes24( MemoryPointer mPtr ) internal pure returns (bytes24 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes25 at `mPtr` in memory. function readBytes25( MemoryPointer mPtr ) internal pure returns (bytes25 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes26 at `mPtr` in memory. function readBytes26( MemoryPointer mPtr ) internal pure returns (bytes26 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes27 at `mPtr` in memory. function readBytes27( MemoryPointer mPtr ) internal pure returns (bytes27 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes28 at `mPtr` in memory. function readBytes28( MemoryPointer mPtr ) internal pure returns (bytes28 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes29 at `mPtr` in memory. function readBytes29( MemoryPointer mPtr ) internal pure returns (bytes29 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes30 at `mPtr` in memory. function readBytes30( MemoryPointer mPtr ) internal pure returns (bytes30 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes31 at `mPtr` in memory. function readBytes31( MemoryPointer mPtr ) internal pure returns (bytes31 value) { assembly { value := mload(mPtr) } } /// @dev Reads the bytes32 at `mPtr` in memory. function readBytes32( MemoryPointer mPtr ) internal pure returns (bytes32 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint8 at `mPtr` in memory. function readUint8(MemoryPointer mPtr) internal pure returns (uint8 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint16 at `mPtr` in memory. function readUint16( MemoryPointer mPtr ) internal pure returns (uint16 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint24 at `mPtr` in memory. function readUint24( MemoryPointer mPtr ) internal pure returns (uint24 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint32 at `mPtr` in memory. function readUint32( MemoryPointer mPtr ) internal pure returns (uint32 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint40 at `mPtr` in memory. function readUint40( MemoryPointer mPtr ) internal pure returns (uint40 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint48 at `mPtr` in memory. function readUint48( MemoryPointer mPtr ) internal pure returns (uint48 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint56 at `mPtr` in memory. function readUint56( MemoryPointer mPtr ) internal pure returns (uint56 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint64 at `mPtr` in memory. function readUint64( MemoryPointer mPtr ) internal pure returns (uint64 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint72 at `mPtr` in memory. function readUint72( MemoryPointer mPtr ) internal pure returns (uint72 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint80 at `mPtr` in memory. function readUint80( MemoryPointer mPtr ) internal pure returns (uint80 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint88 at `mPtr` in memory. function readUint88( MemoryPointer mPtr ) internal pure returns (uint88 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint96 at `mPtr` in memory. function readUint96( MemoryPointer mPtr ) internal pure returns (uint96 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint104 at `mPtr` in memory. function readUint104( MemoryPointer mPtr ) internal pure returns (uint104 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint112 at `mPtr` in memory. function readUint112( MemoryPointer mPtr ) internal pure returns (uint112 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint120 at `mPtr` in memory. function readUint120( MemoryPointer mPtr ) internal pure returns (uint120 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint128 at `mPtr` in memory. function readUint128( MemoryPointer mPtr ) internal pure returns (uint128 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint136 at `mPtr` in memory. function readUint136( MemoryPointer mPtr ) internal pure returns (uint136 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint144 at `mPtr` in memory. function readUint144( MemoryPointer mPtr ) internal pure returns (uint144 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint152 at `mPtr` in memory. function readUint152( MemoryPointer mPtr ) internal pure returns (uint152 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint160 at `mPtr` in memory. function readUint160( MemoryPointer mPtr ) internal pure returns (uint160 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint168 at `mPtr` in memory. function readUint168( MemoryPointer mPtr ) internal pure returns (uint168 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint176 at `mPtr` in memory. function readUint176( MemoryPointer mPtr ) internal pure returns (uint176 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint184 at `mPtr` in memory. function readUint184( MemoryPointer mPtr ) internal pure returns (uint184 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint192 at `mPtr` in memory. function readUint192( MemoryPointer mPtr ) internal pure returns (uint192 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint200 at `mPtr` in memory. function readUint200( MemoryPointer mPtr ) internal pure returns (uint200 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint208 at `mPtr` in memory. function readUint208( MemoryPointer mPtr ) internal pure returns (uint208 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint216 at `mPtr` in memory. function readUint216( MemoryPointer mPtr ) internal pure returns (uint216 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint224 at `mPtr` in memory. function readUint224( MemoryPointer mPtr ) internal pure returns (uint224 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint232 at `mPtr` in memory. function readUint232( MemoryPointer mPtr ) internal pure returns (uint232 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint240 at `mPtr` in memory. function readUint240( MemoryPointer mPtr ) internal pure returns (uint240 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint248 at `mPtr` in memory. function readUint248( MemoryPointer mPtr ) internal pure returns (uint248 value) { assembly { value := mload(mPtr) } } /// @dev Reads the uint256 at `mPtr` in memory. function readUint256( MemoryPointer mPtr ) internal pure returns (uint256 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int8 at `mPtr` in memory. function readInt8(MemoryPointer mPtr) internal pure returns (int8 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int16 at `mPtr` in memory. function readInt16(MemoryPointer mPtr) internal pure returns (int16 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int24 at `mPtr` in memory. function readInt24(MemoryPointer mPtr) internal pure returns (int24 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int32 at `mPtr` in memory. function readInt32(MemoryPointer mPtr) internal pure returns (int32 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int40 at `mPtr` in memory. function readInt40(MemoryPointer mPtr) internal pure returns (int40 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int48 at `mPtr` in memory. function readInt48(MemoryPointer mPtr) internal pure returns (int48 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int56 at `mPtr` in memory. function readInt56(MemoryPointer mPtr) internal pure returns (int56 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int64 at `mPtr` in memory. function readInt64(MemoryPointer mPtr) internal pure returns (int64 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int72 at `mPtr` in memory. function readInt72(MemoryPointer mPtr) internal pure returns (int72 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int80 at `mPtr` in memory. function readInt80(MemoryPointer mPtr) internal pure returns (int80 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int88 at `mPtr` in memory. function readInt88(MemoryPointer mPtr) internal pure returns (int88 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int96 at `mPtr` in memory. function readInt96(MemoryPointer mPtr) internal pure returns (int96 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int104 at `mPtr` in memory. function readInt104( MemoryPointer mPtr ) internal pure returns (int104 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int112 at `mPtr` in memory. function readInt112( MemoryPointer mPtr ) internal pure returns (int112 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int120 at `mPtr` in memory. function readInt120( MemoryPointer mPtr ) internal pure returns (int120 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int128 at `mPtr` in memory. function readInt128( MemoryPointer mPtr ) internal pure returns (int128 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int136 at `mPtr` in memory. function readInt136( MemoryPointer mPtr ) internal pure returns (int136 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int144 at `mPtr` in memory. function readInt144( MemoryPointer mPtr ) internal pure returns (int144 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int152 at `mPtr` in memory. function readInt152( MemoryPointer mPtr ) internal pure returns (int152 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int160 at `mPtr` in memory. function readInt160( MemoryPointer mPtr ) internal pure returns (int160 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int168 at `mPtr` in memory. function readInt168( MemoryPointer mPtr ) internal pure returns (int168 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int176 at `mPtr` in memory. function readInt176( MemoryPointer mPtr ) internal pure returns (int176 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int184 at `mPtr` in memory. function readInt184( MemoryPointer mPtr ) internal pure returns (int184 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int192 at `mPtr` in memory. function readInt192( MemoryPointer mPtr ) internal pure returns (int192 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int200 at `mPtr` in memory. function readInt200( MemoryPointer mPtr ) internal pure returns (int200 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int208 at `mPtr` in memory. function readInt208( MemoryPointer mPtr ) internal pure returns (int208 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int216 at `mPtr` in memory. function readInt216( MemoryPointer mPtr ) internal pure returns (int216 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int224 at `mPtr` in memory. function readInt224( MemoryPointer mPtr ) internal pure returns (int224 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int232 at `mPtr` in memory. function readInt232( MemoryPointer mPtr ) internal pure returns (int232 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int240 at `mPtr` in memory. function readInt240( MemoryPointer mPtr ) internal pure returns (int240 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int248 at `mPtr` in memory. function readInt248( MemoryPointer mPtr ) internal pure returns (int248 value) { assembly { value := mload(mPtr) } } /// @dev Reads the int256 at `mPtr` in memory. function readInt256( MemoryPointer mPtr ) internal pure returns (int256 value) { assembly { value := mload(mPtr) } } } library MemoryWriters { /// @dev Writes `valuePtr` to memory at `mPtr`. function write(MemoryPointer mPtr, MemoryPointer valuePtr) internal pure { assembly { mstore(mPtr, valuePtr) } } /// @dev Writes a boolean `value` to `mPtr` in memory. function write(MemoryPointer mPtr, bool value) internal pure { assembly { mstore(mPtr, value) } } /// @dev Writes an address `value` to `mPtr` in memory. function write(MemoryPointer mPtr, address value) internal pure { assembly { mstore(mPtr, value) } } /// @dev Writes a bytes32 `value` to `mPtr` in memory. /// Separate name to disambiguate literal write parameters. function writeBytes32(MemoryPointer mPtr, bytes32 value) internal pure { assembly { mstore(mPtr, value) } } /// @dev Writes a uint256 `value` to `mPtr` in memory. function write(MemoryPointer mPtr, uint256 value) internal pure { assembly { mstore(mPtr, value) } } /// @dev Writes an int256 `value` to `mPtr` in memory. /// Separate name to disambiguate literal write parameters. function writeInt(MemoryPointer mPtr, int256 value) internal pure { assembly { mstore(mPtr, value) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; /** * @title TwoStepOwnableInterface * @author OpenSea Protocol * @notice TwoStepOwnableInterface contains all external function interfaces, * events and errors for the TwoStepOwnable contract. */ interface TwoStepOwnableInterface { /** * @dev Emit an event whenever the contract owner registers a new potential * owner. * * @param newPotentialOwner The new potential owner of the contract. */ event PotentialOwnerUpdated(address newPotentialOwner); /** * @dev Emit an event whenever contract ownership is transferred. * * @param previousOwner The previous owner of the contract. * @param newOwner The new owner of the contract. */ event OwnershipTransferred(address previousOwner, address newOwner); /** * @dev Revert with an error when attempting to set an initial owner when * one has already been set. */ error OwnerAlreadySet(address currentOwner); /** * @dev Revert with an error when attempting to call a function with the * onlyOwner modifier from an account other than that of the owner. */ error CallerIsNotOwner(); /** * @dev Revert with an error when attempting to register an initial owner * and supplying the null address. */ error InitialOwnerIsNullAddress(); /** * @dev Revert with an error when attempting to register a new potential * owner and supplying the null address. */ error NewPotentialOwnerIsNullAddress(); /** * @dev Revert with an error when attempting to claim ownership of the * contract with a caller that is not the current potential owner. */ error CallerIsNotNewPotentialOwner(); /** * @notice Initiate ownership transfer by assigning a new potential owner * to this contract. Once set, the new potential owner may call * `acceptOwnership` to claim ownership. Only the owner may call * this function. * * @param newPotentialOwner The address for which to initiate ownership * transfer to. */ function transferOwnership(address newPotentialOwner) external; /** * @notice Clear the currently set potential owner, if any. Only the owner * of this contract may call this function. */ function cancelOwnershipTransfer() external; /** * @notice Accept ownership of this contract. Only the account that the * current owner has set as the new potential owner may call this * function. */ function acceptOwnership() external; /** * @notice An external view function that returns the potential owner. * * @return The address of the potential owner. */ function potentialOwner() external view returns (address); /** * @notice An external view function that returns the owner. * * @return The address of the owner. */ function owner() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import { ConduitItemType } from "./ConduitEnums.sol"; /** * @dev A ConduitTransfer is a struct that contains the information needed for a * conduit to transfer an item from one address to another. */ struct ConduitTransfer { ConduitItemType itemType; address token; address from; address to; uint256 identifier; uint256 amount; } /** * @dev A ConduitBatch1155Transfer is a struct that contains the information * needed for a conduit to transfer a batch of ERC-1155 tokens from one * address to another. */ struct ConduitBatch1155Transfer { address token; address from; address to; uint256[] ids; uint256[] amounts; }
{ "remappings": [ "forge-std/=lib/forge-std/src/", "safe-tools/=lib/safe-tools/src/", "@openzeppelin/=lib/openzeppelin-contracts/", "@openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/", "@interfaces/=src/interfaces/", "@mocks/=test/mocks/", "@script/=script/", "safe/=lib/safer/lib/safe-contracts/contracts/", "ds-test/=lib/forge-std/lib/ds-test/src/", "safer/=lib/safer/", "@balancer-labs/v2-interfaces/=lib/ion-protocol/lib/balancer-v2-monorepo/pkg/interfaces/", "@balancer-labs/v2-pool-stable/=lib/ion-protocol/lib/balancer-v2-monorepo/pkg/pool-stable/", "@chainlink/contracts/=lib/ion-protocol/lib/chainlink/contracts/", "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/", "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/", "@uniswap/v3-core/=lib/ion-protocol/lib/v3-core/", "@uniswap/v3-periphery/=lib/ion-protocol/lib/v3-periphery/", "addresses/=lib/addresses/src/", "balancer-v2-monorepo/=lib/ion-protocol/lib/", "chainlink/=lib/ion-protocol/lib/chainlink/", "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/", "forge-safe/=lib/ion-protocol/lib/forge-safe/", "ion-protocol/=lib/ion-protocol/", "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "openzeppelin/=lib/addresses/lib/openzeppelin-contracts-upgradeable/contracts/", "seaport-core/=lib/seaport-core/", "seaport-types/=lib/seaport-types/", "solady/=lib/ion-protocol/lib/solady/", "solarray/=lib/ion-protocol/lib/solarray/src/", "solidity-stringutils/=lib/ion-protocol/lib/forge-safe/lib/surl/lib/solidity-stringutils/", "solmate/=lib/addresses/lib/solmate/src/", "surl/=lib/ion-protocol/lib/forge-safe/lib/surl/", "transient-goodies/=lib/transient-goodies/src/", "v3-core/=lib/ion-protocol/lib/v3-core/", "v3-periphery/=lib/ion-protocol/lib/v3-periphery/contracts/" ], "optimizer": { "enabled": true, "runs": 100000, "details": { "jumpdestRemover": true, "orderLiterals": true, "deduplicate": true, "cse": true, "constantOptimizer": true, "yul": true, "yulDetails": { "stackAllocation": true } } }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "cancun", "viaIR": true, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"__conduit","type":"address"},{"internalType":"bytes32","name":"__conduitKey","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyEntered","type":"error"},{"inputs":[{"internalType":"address","name":"invalidRecipient","type":"address"}],"name":"C1RecipientMustBeSender","type":"error"},{"inputs":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"}],"name":"C1TypeMustBeERC20","type":"error"},{"inputs":[],"name":"CallerIsNotNewPotentialOwner","type":"error"},{"inputs":[],"name":"CallerIsNotOwner","type":"error"},{"inputs":[{"internalType":"bytes32","name":"conduitKey","type":"bytes32"}],"name":"ConduitKeyMismatch","type":"error"},{"inputs":[],"name":"ConduitTransferFailure","type":"error"},{"inputs":[{"internalType":"uint256","name":"startAmount","type":"uint256"},{"internalType":"uint256","name":"endAmount","type":"uint256"}],"name":"ConsiderationAmountMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"ConsiderationTokenMustBeApproved","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ConsiderationsLengthMustBeOne","type":"error"},{"inputs":[],"name":"ContractDeactivated","type":"error"},{"inputs":[],"name":"InitialOwnerIsNullAddress","type":"error"},{"inputs":[],"name":"InvalidTotalOriginalConsiderationItems","type":"error"},{"inputs":[{"internalType":"address","name":"msgSender","type":"address"}],"name":"MsgSenderMustBeSeaport","type":"error"},{"inputs":[],"name":"NewPotentialOwnerIsNullAddress","type":"error"},{"inputs":[],"name":"NotAwaitingCallback","type":"error"},{"inputs":[],"name":"NotEnteredYet","type":"error"},{"inputs":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"}],"name":"OItemTypeMustBeERC20","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"OTokenMustBeThis","type":"error"},{"inputs":[{"internalType":"uint256","name":"startAmount","type":"uint256"},{"internalType":"uint256","name":"endAmount","type":"uint256"}],"name":"OfferAmountMismatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"OffersLengthMustBeOne","type":"error"},{"inputs":[{"internalType":"enum OrderType","name":"orderType","type":"uint8"}],"name":"OrderTypeMustBeFullRestricted","type":"error"},{"inputs":[{"internalType":"address","name":"currentOwner","type":"address"}],"name":"OwnerAlreadySet","type":"error"},{"inputs":[{"internalType":"bytes32","name":"zoneHash","type":"bytes32"}],"name":"ZoneHashDoesNotContainDepositorAddress","type":"error"},{"inputs":[{"internalType":"address","name":"zone","type":"address"}],"name":"ZoneMustBeThis","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"ConsiderationTokenApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newPotentialOwner","type":"address"}],"name":"PotentialOwnerUpdated","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveConsiderationToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"conduit","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"conduitKey","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deactivate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"offerer","type":"address"},{"internalType":"address","name":"zone","type":"address"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifierOrCriteria","type":"uint256"},{"internalType":"uint256","name":"startAmount","type":"uint256"},{"internalType":"uint256","name":"endAmount","type":"uint256"}],"internalType":"struct OfferItem[]","name":"offer","type":"tuple[]"},{"components":[{"internalType":"enum ItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifierOrCriteria","type":"uint256"},{"internalType":"uint256","name":"startAmount","type":"uint256"},{"internalType":"uint256","name":"endAmount","type":"uint256"},{"internalType":"address payable","name":"recipient","type":"address"}],"internalType":"struct ConsiderationItem[]","name":"consideration","type":"tuple[]"},{"internalType":"enum OrderType","name":"orderType","type":"uint8"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"bytes32","name":"zoneHash","type":"bytes32"},{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"bytes32","name":"conduitKey","type":"bytes32"},{"internalType":"uint256","name":"totalOriginalConsiderationItems","type":"uint256"}],"internalType":"struct OrderParameters","name":"parameters","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"generatePointTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isApprovedConsiderationToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"potentialOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seaport","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"depositAmount","type":"uint256"}],"name":"seaportCallback4878572495","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newPotentialOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000a8c94ae38b04140794a9394b76ac6d0a83ac0b020000000000000000000000009352da82f42c5bdde9f0b2c19d635bae39142dd8a8c94ae38b04140794a9394b76ac6d0a83ac0b02000000000000000000000000
-----Decoded View---------------
Arg [0] : _owner (address): 0xa8C94AE38B04140794A9394b76Ac6d0A83AC0B02
Arg [1] : __conduit (address): 0x9352dA82F42c5bDDe9F0b2C19D635baE39142dD8
Arg [2] : __conduitKey (bytes32): 0xa8c94ae38b04140794a9394b76ac6d0a83ac0b02000000000000000000000000
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000a8c94ae38b04140794a9394b76ac6d0a83ac0b02
Arg [1] : 0000000000000000000000009352da82f42c5bdde9f0b2c19d635bae39142dd8
Arg [2] : a8c94ae38b04140794a9394b76ac6d0a83ac0b02000000000000000000000000
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ 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.